test/CodeGen/AArch64/neon-2velem.ll

   1 ; RUN: llc < %s -verify-machineinstrs -mtriple=aarch64-none-linux-gnu -mattr=+neon -fp-contract=fast | FileCheck %s
   2 ; arm64 has copied test in its directory due to differing intrinsics.
   3
   4 declare <2 x double> @llvm.aarch64.neon.vmulx.v2f64(<2 x double>, <2 x double>)
   5
   6 declare <4 x float> @llvm.aarch64.neon.vmulx.v4f32(<4 x float>, <4 x float>)
   7
   8 declare <2 x float> @llvm.aarch64.neon.vmulx.v2f32(<2 x float>, <2 x float>)
   9
  10 declare <4 x i32> @llvm.arm.neon.vqrdmulh.v4i32(<4 x i32>, <4 x i32>)
  11
  12 declare <2 x i32> @llvm.arm.neon.vqrdmulh.v2i32(<2 x i32>, <2 x i32>)
  13
  14 declare <8 x i16> @llvm.arm.neon.vqrdmulh.v8i16(<8 x i16>, <8 x i16>)
  15
  16 declare <4 x i16> @llvm.arm.neon.vqrdmulh.v4i16(<4 x i16>, <4 x i16>)
  17
  18 declare <4 x i32> @llvm.arm.neon.vqdmulh.v4i32(<4 x i32>, <4 x i32>)
  19
  20 declare <2 x i32> @llvm.arm.neon.vqdmulh.v2i32(<2 x i32>, <2 x i32>)
  21
  22 declare <8 x i16> @llvm.arm.neon.vqdmulh.v8i16(<8 x i16>, <8 x i16>)
  23
  24 declare <4 x i16> @llvm.arm.neon.vqdmulh.v4i16(<4 x i16>, <4 x i16>)
  25
  26 declare <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32>, <2 x i32>)
  27
  28 declare <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16>, <4 x i16>)
  29
  30 declare <2 x i64> @llvm.arm.neon.vqsubs.v2i64(<2 x i64>, <2 x i64>)
  31
  32 declare <4 x i32> @llvm.arm.neon.vqsubs.v4i32(<4 x i32>, <4 x i32>)
  33
  34 declare <2 x i64> @llvm.arm.neon.vqadds.v2i64(<2 x i64>, <2 x i64>)
  35
  36 declare <4 x i32> @llvm.arm.neon.vqadds.v4i32(<4 x i32>, <4 x i32>)
  37
  38 declare <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32>, <2 x i32>)
  39
  40 declare <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16>, <4 x i16>)
  41
  42 declare <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32>, <2 x i32>)
  43
  44 declare <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16>, <4 x i16>)
  45
  46 define <4 x i16> @test_vmla_lane_s16(<4 x i16> %a, <4 x i16> %b, <4 x i16> %v) {
  47 ; CHECK: test_vmla_lane_s16:
  48 ; CHECK: mla {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
  49 ; CHECK-NEXT: ret
  50 entry:
  51   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
  52   %mul = mul <4 x i16> %shuffle, %b
  53   %add = add <4 x i16> %mul, %a
  54   ret <4 x i16> %add
  55 }
  56
  57 define <8 x i16> @test_vmlaq_lane_s16(<8 x i16> %a, <8 x i16> %b, <4 x i16> %v) {
  58 ; CHECK: test_vmlaq_lane_s16:
  59 ; CHECK: mla {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
  60 ; CHECK-NEXT: ret
  61 entry:
  62   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <8 x i32> <i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3>
  63   %mul = mul <8 x i16> %shuffle, %b
  64   %add = add <8 x i16> %mul, %a
  65   ret <8 x i16> %add
  66 }
  67
  68 define <2 x i32> @test_vmla_lane_s32(<2 x i32> %a, <2 x i32> %b, <2 x i32> %v) {
  69 ; CHECK: test_vmla_lane_s32:
  70 ; CHECK: mla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
  71 ; CHECK-NEXT: ret
  72 entry:
  73   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
  74   %mul = mul <2 x i32> %shuffle, %b
  75   %add = add <2 x i32> %mul, %a
  76   ret <2 x i32> %add
  77 }
  78
  79 define <4 x i32> @test_vmlaq_lane_s32(<4 x i32> %a, <4 x i32> %b, <2 x i32> %v) {
  80 ; CHECK: test_vmlaq_lane_s32:
  81 ; CHECK: mla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
  82 ; CHECK-NEXT: ret
  83 entry:
  84   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
  85   %mul = mul <4 x i32> %shuffle, %b
  86   %add = add <4 x i32> %mul, %a
  87   ret <4 x i32> %add
  88 }
  89
  90 define <4 x i16> @test_vmla_laneq_s16(<4 x i16> %a, <4 x i16> %b, <8 x i16> %v) {
  91 ; CHECK: test_vmla_laneq_s16:
  92 ; CHECK: mla {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
  93 ; CHECK-NEXT: ret
  94 entry:
  95   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
  96   %mul = mul <4 x i16> %shuffle, %b
  97   %add = add <4 x i16> %mul, %a
  98   ret <4 x i16> %add
  99 }
 100
 101 define <8 x i16> @test_vmlaq_laneq_s16(<8 x i16> %a, <8 x i16> %b, <8 x i16> %v) {
 102 ; CHECK: test_vmlaq_laneq_s16:
 103 ; CHECK: mla {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 104 ; CHECK-NEXT: ret
 105 entry:
 106   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7>
 107   %mul = mul <8 x i16> %shuffle, %b
 108   %add = add <8 x i16> %mul, %a
 109   ret <8 x i16> %add
 110 }
 111
 112 define <2 x i32> @test_vmla_laneq_s32(<2 x i32> %a, <2 x i32> %b, <4 x i32> %v) {
 113 ; CHECK: test_vmla_laneq_s32:
 114 ; CHECK: mla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 115 ; CHECK-NEXT: ret
 116 entry:
 117   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
 118   %mul = mul <2 x i32> %shuffle, %b
 119   %add = add <2 x i32> %mul, %a
 120   ret <2 x i32> %add
 121 }
 122
 123 define <4 x i32> @test_vmlaq_laneq_s32(<4 x i32> %a, <4 x i32> %b, <4 x i32> %v) {
 124 ; CHECK: test_vmlaq_laneq_s32:
 125 ; CHECK: mla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 126 ; CHECK-NEXT: ret
 127 entry:
 128   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 129   %mul = mul <4 x i32> %shuffle, %b
 130   %add = add <4 x i32> %mul, %a
 131   ret <4 x i32> %add
 132 }
 133
 134 define <4 x i16> @test_vmls_lane_s16(<4 x i16> %a, <4 x i16> %b, <4 x i16> %v) {
 135 ; CHECK: test_vmls_lane_s16:
 136 ; CHECK: mls {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 137 ; CHECK-NEXT: ret
 138 entry:
 139   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 140   %mul = mul <4 x i16> %shuffle, %b
 141   %sub = sub <4 x i16> %a, %mul
 142   ret <4 x i16> %sub
 143 }
 144
 145 define <8 x i16> @test_vmlsq_lane_s16(<8 x i16> %a, <8 x i16> %b, <4 x i16> %v) {
 146 ; CHECK: test_vmlsq_lane_s16:
 147 ; CHECK: mls {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 148 ; CHECK-NEXT: ret
 149 entry:
 150   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <8 x i32> <i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3>
 151   %mul = mul <8 x i16> %shuffle, %b
 152   %sub = sub <8 x i16> %a, %mul
 153   ret <8 x i16> %sub
 154 }
 155
 156 define <2 x i32> @test_vmls_lane_s32(<2 x i32> %a, <2 x i32> %b, <2 x i32> %v) {
 157 ; CHECK: test_vmls_lane_s32:
 158 ; CHECK: mls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 159 ; CHECK-NEXT: ret
 160 entry:
 161   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
 162   %mul = mul <2 x i32> %shuffle, %b
 163   %sub = sub <2 x i32> %a, %mul
 164   ret <2 x i32> %sub
 165 }
 166
 167 define <4 x i32> @test_vmlsq_lane_s32(<4 x i32> %a, <4 x i32> %b, <2 x i32> %v) {
 168 ; CHECK: test_vmlsq_lane_s32:
 169 ; CHECK: mls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 170 ; CHECK-NEXT: ret
 171 entry:
 172   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
 173   %mul = mul <4 x i32> %shuffle, %b
 174   %sub = sub <4 x i32> %a, %mul
 175   ret <4 x i32> %sub
 176 }
 177
 178 define <4 x i16> @test_vmls_laneq_s16(<4 x i16> %a, <4 x i16> %b, <8 x i16> %v) {
 179 ; CHECK: test_vmls_laneq_s16:
 180 ; CHECK: mls {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 181 ; CHECK-NEXT: ret
 182 entry:
 183   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
 184   %mul = mul <4 x i16> %shuffle, %b
 185   %sub = sub <4 x i16> %a, %mul
 186   ret <4 x i16> %sub
 187 }
 188
 189 define <8 x i16> @test_vmlsq_laneq_s16(<8 x i16> %a, <8 x i16> %b, <8 x i16> %v) {
 190 ; CHECK: test_vmlsq_laneq_s16:
 191 ; CHECK: mls {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 192 ; CHECK-NEXT: ret
 193 entry:
 194   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7>
 195   %mul = mul <8 x i16> %shuffle, %b
 196   %sub = sub <8 x i16> %a, %mul
 197   ret <8 x i16> %sub
 198 }
 199
 200 define <2 x i32> @test_vmls_laneq_s32(<2 x i32> %a, <2 x i32> %b, <4 x i32> %v) {
 201 ; CHECK: test_vmls_laneq_s32:
 202 ; CHECK: mls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 203 ; CHECK-NEXT: ret
 204 entry:
 205   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
 206   %mul = mul <2 x i32> %shuffle, %b
 207   %sub = sub <2 x i32> %a, %mul
 208   ret <2 x i32> %sub
 209 }
 210
 211 define <4 x i32> @test_vmlsq_laneq_s32(<4 x i32> %a, <4 x i32> %b, <4 x i32> %v) {
 212 ; CHECK: test_vmlsq_laneq_s32:
 213 ; CHECK: mls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 214 ; CHECK-NEXT: ret
 215 entry:
 216   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 217   %mul = mul <4 x i32> %shuffle, %b
 218   %sub = sub <4 x i32> %a, %mul
 219   ret <4 x i32> %sub
 220 }
 221
 222 define <4 x i16> @test_vmul_lane_s16(<4 x i16> %a, <4 x i16> %v) {
 223 ; CHECK: test_vmul_lane_s16:
 224 ; CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 225 ; CHECK-NEXT: ret
 226 entry:
 227   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 228   %mul = mul <4 x i16> %shuffle, %a
 229   ret <4 x i16> %mul
 230 }
 231
 232 define <8 x i16> @test_vmulq_lane_s16(<8 x i16> %a, <4 x i16> %v) {
 233 ; CHECK: test_vmulq_lane_s16:
 234 ; CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 235 ; CHECK-NEXT: ret
 236 entry:
 237   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <8 x i32> <i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3>
 238   %mul = mul <8 x i16> %shuffle, %a
 239   ret <8 x i16> %mul
 240 }
 241
 242 define <2 x i32> @test_vmul_lane_s32(<2 x i32> %a, <2 x i32> %v) {
 243 ; CHECK: test_vmul_lane_s32:
 244 ; CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 245 ; CHECK-NEXT: ret
 246 entry:
 247   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
 248   %mul = mul <2 x i32> %shuffle, %a
 249   ret <2 x i32> %mul
 250 }
 251
 252 define <4 x i32> @test_vmulq_lane_s32(<4 x i32> %a, <2 x i32> %v) {
 253 ; CHECK: test_vmulq_lane_s32:
 254 ; CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 255 ; CHECK-NEXT: ret
 256 entry:
 257   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
 258   %mul = mul <4 x i32> %shuffle, %a
 259   ret <4 x i32> %mul
 260 }
 261
 262 define <4 x i16> @test_vmul_lane_u16(<4 x i16> %a, <4 x i16> %v) {
 263 ; CHECK: test_vmul_lane_u16:
 264 ; CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 265 ; CHECK-NEXT: ret
 266 entry:
 267   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 268   %mul = mul <4 x i16> %shuffle, %a
 269   ret <4 x i16> %mul
 270 }
 271
 272 define <8 x i16> @test_vmulq_lane_u16(<8 x i16> %a, <4 x i16> %v) {
 273 ; CHECK: test_vmulq_lane_u16:
 274 ; CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 275 ; CHECK-NEXT: ret
 276 entry:
 277   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <8 x i32> <i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3>
 278   %mul = mul <8 x i16> %shuffle, %a
 279   ret <8 x i16> %mul
 280 }
 281
 282 define <2 x i32> @test_vmul_lane_u32(<2 x i32> %a, <2 x i32> %v) {
 283 ; CHECK: test_vmul_lane_u32:
 284 ; CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 285 ; CHECK-NEXT: ret
 286 entry:
 287   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
 288   %mul = mul <2 x i32> %shuffle, %a
 289   ret <2 x i32> %mul
 290 }
 291
 292 define <4 x i32> @test_vmulq_lane_u32(<4 x i32> %a, <2 x i32> %v) {
 293 ; CHECK: test_vmulq_lane_u32:
 294 ; CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 295 ; CHECK-NEXT: ret
 296 entry:
 297   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
 298   %mul = mul <4 x i32> %shuffle, %a
 299   ret <4 x i32> %mul
 300 }
 301
 302 define <4 x i16> @test_vmul_laneq_s16(<4 x i16> %a, <8 x i16> %v) {
 303 ; CHECK: test_vmul_laneq_s16:
 304 ; CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 305 ; CHECK-NEXT: ret
 306 entry:
 307   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
 308   %mul = mul <4 x i16> %shuffle, %a
 309   ret <4 x i16> %mul
 310 }
 311
 312 define <8 x i16> @test_vmulq_laneq_s16(<8 x i16> %a, <8 x i16> %v) {
 313 ; CHECK: test_vmulq_laneq_s16:
 314 ; CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 315 ; CHECK-NEXT: ret
 316 entry:
 317   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7>
 318   %mul = mul <8 x i16> %shuffle, %a
 319   ret <8 x i16> %mul
 320 }
 321
 322 define <2 x i32> @test_vmul_laneq_s32(<2 x i32> %a, <4 x i32> %v) {
 323 ; CHECK: test_vmul_laneq_s32:
 324 ; CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 325 ; CHECK-NEXT: ret
 326 entry:
 327   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
 328   %mul = mul <2 x i32> %shuffle, %a
 329   ret <2 x i32> %mul
 330 }
 331
 332 define <4 x i32> @test_vmulq_laneq_s32(<4 x i32> %a, <4 x i32> %v) {
 333 ; CHECK: test_vmulq_laneq_s32:
 334 ; CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 335 ; CHECK-NEXT: ret
 336 entry:
 337   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 338   %mul = mul <4 x i32> %shuffle, %a
 339   ret <4 x i32> %mul
 340 }
 341
 342 define <4 x i16> @test_vmul_laneq_u16(<4 x i16> %a, <8 x i16> %v) {
 343 ; CHECK: test_vmul_laneq_u16:
 344 ; CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 345 ; CHECK-NEXT: ret
 346 entry:
 347   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
 348   %mul = mul <4 x i16> %shuffle, %a
 349   ret <4 x i16> %mul
 350 }
 351
 352 define <8 x i16> @test_vmulq_laneq_u16(<8 x i16> %a, <8 x i16> %v) {
 353 ; CHECK: test_vmulq_laneq_u16:
 354 ; CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 355 ; CHECK-NEXT: ret
 356 entry:
 357   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <8 x i32> <i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7, i32 7>
 358   %mul = mul <8 x i16> %shuffle, %a
 359   ret <8 x i16> %mul
 360 }
 361
 362 define <2 x i32> @test_vmul_laneq_u32(<2 x i32> %a, <4 x i32> %v) {
 363 ; CHECK: test_vmul_laneq_u32:
 364 ; CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 365 ; CHECK-NEXT: ret
 366 entry:
 367   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
 368   %mul = mul <2 x i32> %shuffle, %a
 369   ret <2 x i32> %mul
 370 }
 371
 372 define <4 x i32> @test_vmulq_laneq_u32(<4 x i32> %a, <4 x i32> %v) {
 373 ; CHECK: test_vmulq_laneq_u32:
 374 ; CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 375 ; CHECK-NEXT: ret
 376 entry:
 377   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 378   %mul = mul <4 x i32> %shuffle, %a
 379   ret <4 x i32> %mul
 380 }
 381
 382 define <2 x float> @test_vfma_lane_f32(<2 x float> %a, <2 x float> %b, <2 x float> %v) {
 383 ; CHECK: test_vfma_lane_f32:
 384 ; CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 385 ; CHECK-NEXT: ret
 386 entry:
 387   %lane = shufflevector <2 x float> %v, <2 x float> undef, <2 x i32> <i32 1, i32 1>
 388   %0 = tail call <2 x float> @llvm.fma.v2f32(<2 x float> %lane, <2 x float> %b, <2 x float> %a)
 389   ret <2 x float> %0
 390 }
 391
 392 declare <2 x float> @llvm.fma.v2f32(<2 x float>, <2 x float>, <2 x float>)
 393
 394 define <4 x float> @test_vfmaq_lane_f32(<4 x float> %a, <4 x float> %b, <2 x float> %v) {
 395 ; CHECK: test_vfmaq_lane_f32:
 396 ; CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 397 ; CHECK-NEXT: ret
 398 entry:
 399   %lane = shufflevector <2 x float> %v, <2 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
 400   %0 = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %lane, <4 x float> %b, <4 x float> %a)
 401   ret <4 x float> %0
 402 }
 403
 404 declare <4 x float> @llvm.fma.v4f32(<4 x float>, <4 x float>, <4 x float>)
 405
 406 define <2 x float> @test_vfma_laneq_f32(<2 x float> %a, <2 x float> %b, <4 x float> %v) {
 407 ; CHECK: test_vfma_laneq_f32:
 408 ; CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 409 ; CHECK-NEXT: ret
 410 entry:
 411   %lane = shufflevector <4 x float> %v, <4 x float> undef, <2 x i32> <i32 3, i32 3>
 412   %0 = tail call <2 x float> @llvm.fma.v2f32(<2 x float> %lane, <2 x float> %b, <2 x float> %a)
 413   ret <2 x float> %0
 414 }
 415
 416 define <4 x float> @test_vfmaq_laneq_f32(<4 x float> %a, <4 x float> %b, <4 x float> %v) {
 417 ; CHECK: test_vfmaq_laneq_f32:
 418 ; CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 419 ; CHECK-NEXT: ret
 420 entry:
 421   %lane = shufflevector <4 x float> %v, <4 x float> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 422   %0 = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %lane, <4 x float> %b, <4 x float> %a)
 423   ret <4 x float> %0
 424 }
 425
 426 define <2 x float> @test_vfms_lane_f32(<2 x float> %a, <2 x float> %b, <2 x float> %v) {
 427 ; CHECK: test_vfms_lane_f32:
 428 ; CHECK: fmls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 429 ; CHECK-NEXT: ret
 430 entry:
 431   %sub = fsub <2 x float> <float -0.000000e+00, float -0.000000e+00>, %v
 432   %lane = shufflevector <2 x float> %sub, <2 x float> undef, <2 x i32> <i32 1, i32 1>
 433   %0 = tail call <2 x float> @llvm.fma.v2f32(<2 x float> %lane, <2 x float> %b, <2 x float> %a)
 434   ret <2 x float> %0
 435 }
 436
 437 define <4 x float> @test_vfmsq_lane_f32(<4 x float> %a, <4 x float> %b, <2 x float> %v) {
 438 ; CHECK: test_vfmsq_lane_f32:
 439 ; CHECK: fmls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 440 ; CHECK-NEXT: ret
 441 entry:
 442   %sub = fsub <2 x float> <float -0.000000e+00, float -0.000000e+00>, %v
 443   %lane = shufflevector <2 x float> %sub, <2 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
 444   %0 = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %lane, <4 x float> %b, <4 x float> %a)
 445   ret <4 x float> %0
 446 }
 447
 448 define <2 x float> @test_vfms_laneq_f32(<2 x float> %a, <2 x float> %b, <4 x float> %v) {
 449 ; CHECK: test_vfms_laneq_f32:
 450 ; CHECK: fmls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 451 ; CHECK-NEXT: ret
 452 entry:
 453   %sub = fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %v
 454   %lane = shufflevector <4 x float> %sub, <4 x float> undef, <2 x i32> <i32 3, i32 3>
 455   %0 = tail call <2 x float> @llvm.fma.v2f32(<2 x float> %lane, <2 x float> %b, <2 x float> %a)
 456   ret <2 x float> %0
 457 }
 458
 459 define <4 x float> @test_vfmsq_laneq_f32(<4 x float> %a, <4 x float> %b, <4 x float> %v) {
 460 ; CHECK: test_vfmsq_laneq_f32:
 461 ; CHECK: fmls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 462 ; CHECK-NEXT: ret
 463 entry:
 464   %sub = fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %v
 465   %lane = shufflevector <4 x float> %sub, <4 x float> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 466   %0 = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %lane, <4 x float> %b, <4 x float> %a)
 467   ret <4 x float> %0
 468 }
 469
 470 define <2 x double> @test_vfmaq_lane_f64(<2 x double> %a, <2 x double> %b, <1 x double> %v) {
 471 ; CHECK: test_vfmaq_lane_f64:
 472 ; CHECK: fmla {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 473 ; CHECK-NEXT: ret
 474 entry:
 475   %lane = shufflevector <1 x double> %v, <1 x double> undef, <2 x i32> zeroinitializer
 476   %0 = tail call <2 x double> @llvm.fma.v2f64(<2 x double> %lane, <2 x double> %b, <2 x double> %a)
 477   ret <2 x double> %0
 478 }
 479
 480 declare <2 x double> @llvm.fma.v2f64(<2 x double>, <2 x double>, <2 x double>)
 481
 482 define <2 x double> @test_vfmaq_laneq_f64(<2 x double> %a, <2 x double> %b, <2 x double> %v) {
 483 ; CHECK: test_vfmaq_laneq_f64:
 484 ; CHECK: fmla {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[1]
 485 ; CHECK-NEXT: ret
 486 entry:
 487   %lane = shufflevector <2 x double> %v, <2 x double> undef, <2 x i32> <i32 1, i32 1>
 488   %0 = tail call <2 x double> @llvm.fma.v2f64(<2 x double> %lane, <2 x double> %b, <2 x double> %a)
 489   ret <2 x double> %0
 490 }
 491
 492 define <2 x double> @test_vfmsq_lane_f64(<2 x double> %a, <2 x double> %b, <1 x double> %v) {
 493 ; CHECK: test_vfmsq_lane_f64:
 494 ; CHECK: fmls {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
 495 ; CHECK-NEXT: ret
 496 entry:
 497   %sub = fsub <1 x double> <double -0.000000e+00>, %v
 498   %lane = shufflevector <1 x double> %sub, <1 x double> undef, <2 x i32> zeroinitializer
 499   %0 = tail call <2 x double> @llvm.fma.v2f64(<2 x double> %lane, <2 x double> %b, <2 x double> %a)
 500   ret <2 x double> %0
 501 }
 502
 503 define <2 x double> @test_vfmsq_laneq_f64(<2 x double> %a, <2 x double> %b, <2 x double> %v) {
 504 ; CHECK: test_vfmsq_laneq_f64:
 505 ; CHECK: fmls {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[1]
 506 ; CHECK-NEXT: ret
 507 entry:
 508   %sub = fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %v
 509   %lane = shufflevector <2 x double> %sub, <2 x double> undef, <2 x i32> <i32 1, i32 1>
 510   %0 = tail call <2 x double> @llvm.fma.v2f64(<2 x double> %lane, <2 x double> %b, <2 x double> %a)
 511   ret <2 x double> %0
 512 }
 513
 514 define float @test_vfmas_laneq_f32(float %a, float %b, <4 x float> %v) {
 515 ; CHECK-LABEL: test_vfmas_laneq_f32
 516 ; CHECK: fmla {{s[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[3]
 517 ; CHECK-NEXT: ret
 518 entry:
 519   %extract = extractelement <4 x float> %v, i32 3
 520   %0 = tail call float @llvm.fma.f32(float %b, float %extract, float %a)
 521   ret float %0
 522 }
 523
 524 declare float @llvm.fma.f32(float, float, float)
 525
 526 define double @test_vfmsd_lane_f64(double %a, double %b, <1 x double> %v) {
 527 ; CHECK-LABEL: test_vfmsd_lane_f64
 528 ; CHECK: fmls {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
 529 ; CHECK-NEXT: ret
 530 entry:
 531   %extract.rhs = extractelement <1 x double> %v, i32 0
 532   %extract = fsub double -0.000000e+00, %extract.rhs
 533   %0 = tail call double @llvm.fma.f64(double %b, double %extract, double %a)
 534   ret double %0
 535 }
 536
 537 declare double @llvm.fma.f64(double, double, double)
 538
 539 define float @test_vfmss_laneq_f32(float %a, float %b, <4 x float> %v) {
 540 ; CHECK: test_vfmss_laneq_f32
 541 ; CHECK: fmls {{s[0-9]+}}, {{s[0-9]+}}, {{v[0-9]+}}.s[3]
 542 ; CHECK-NEXT: ret
 543 entry:
 544   %extract.rhs = extractelement <4 x float> %v, i32 3
 545   %extract = fsub float -0.000000e+00, %extract.rhs
 546   %0 = tail call float @llvm.fma.f32(float %b, float %extract, float %a)
 547   ret float %0
 548 }
 549
 550 define double @test_vfmsd_laneq_f64(double %a, double %b, <2 x double> %v) {
 551 ; CHECK-LABEL: test_vfmsd_laneq_f64
 552 ; CHECK: fmls {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[1]
 553 ; CHECK-NEXT: ret
 554 entry:
 555   %extract.rhs = extractelement <2 x double> %v, i32 1
 556   %extract = fsub double -0.000000e+00, %extract.rhs
 557   %0 = tail call double @llvm.fma.f64(double %b, double %extract, double %a)
 558   ret double %0
 559 }
 560
 561 define <4 x i32> @test_vmlal_lane_s16(<4 x i32> %a, <4 x i16> %b, <4 x i16> %v) {
 562 ; CHECK: test_vmlal_lane_s16:
 563 ; CHECK: mlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 564 ; CHECK-NEXT: ret
 565 entry:
 566   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 567   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
 568   %add = add <4 x i32> %vmull2.i, %a
 569   ret <4 x i32> %add
 570 }
 571
 572 define <2 x i64> @test_vmlal_lane_s32(<2 x i64> %a, <2 x i32> %b, <2 x i32> %v) {
 573 ; CHECK: test_vmlal_lane_s32:
 574 ; CHECK: mlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 575 ; CHECK-NEXT: ret
 576 entry:
 577   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
 578   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
 579   %add = add <2 x i64> %vmull2.i, %a
 580   ret <2 x i64> %add
 581 }
 582
 583 define <4 x i32> @test_vmlal_laneq_s16(<4 x i32> %a, <4 x i16> %b, <8 x i16> %v) {
 584 ; CHECK: test_vmlal_laneq_s16:
 585 ; CHECK: mlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 586 ; CHECK-NEXT: ret
 587 entry:
 588   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
 589   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
 590   %add = add <4 x i32> %vmull2.i, %a
 591   ret <4 x i32> %add
 592 }
 593
 594 define <2 x i64> @test_vmlal_laneq_s32(<2 x i64> %a, <2 x i32> %b, <4 x i32> %v) {
 595 ; CHECK: test_vmlal_laneq_s32:
 596 ; CHECK: mlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 597 ; CHECK-NEXT: ret
 598 entry:
 599   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
 600   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
 601   %add = add <2 x i64> %vmull2.i, %a
 602   ret <2 x i64> %add
 603 }
 604
 605 define <4 x i32> @test_vmlal_high_lane_s16(<4 x i32> %a, <8 x i16> %b, <4 x i16> %v) {
 606 ; CHECK: test_vmlal_high_lane_s16:
 607 ; CHECK: mlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 608 ; CHECK-NEXT: ret
 609 entry:
 610   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
 611   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 612   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
 613   %add = add <4 x i32> %vmull2.i, %a
 614   ret <4 x i32> %add
 615 }
 616
 617 define <2 x i64> @test_vmlal_high_lane_s32(<2 x i64> %a, <4 x i32> %b, <2 x i32> %v) {
 618 ; CHECK: test_vmlal_high_lane_s32:
 619 ; CHECK: mlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 620 ; CHECK-NEXT: ret
 621 entry:
 622   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
 623   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
 624   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
 625   %add = add <2 x i64> %vmull2.i, %a
 626   ret <2 x i64> %add
 627 }
 628
 629 define <4 x i32> @test_vmlal_high_laneq_s16(<4 x i32> %a, <8 x i16> %b, <8 x i16> %v) {
 630 ; CHECK: test_vmlal_high_laneq_s16:
 631 ; CHECK: mlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 632 ; CHECK-NEXT: ret
 633 entry:
 634   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
 635   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
 636   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
 637   %add = add <4 x i32> %vmull2.i, %a
 638   ret <4 x i32> %add
 639 }
 640
 641 define <2 x i64> @test_vmlal_high_laneq_s32(<2 x i64> %a, <4 x i32> %b, <4 x i32> %v) {
 642 ; CHECK: test_vmlal_high_laneq_s32:
 643 ; CHECK: mlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 644 ; CHECK-NEXT: ret
 645 entry:
 646   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
 647   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
 648   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
 649   %add = add <2 x i64> %vmull2.i, %a
 650   ret <2 x i64> %add
 651 }
 652
 653 define <4 x i32> @test_vmlsl_lane_s16(<4 x i32> %a, <4 x i16> %b, <4 x i16> %v) {
 654 ; CHECK: test_vmlsl_lane_s16:
 655 ; CHECK: mlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 656 ; CHECK-NEXT: ret
 657 entry:
 658   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 659   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
 660   %sub = sub <4 x i32> %a, %vmull2.i
 661   ret <4 x i32> %sub
 662 }
 663
 664 define <2 x i64> @test_vmlsl_lane_s32(<2 x i64> %a, <2 x i32> %b, <2 x i32> %v) {
 665 ; CHECK: test_vmlsl_lane_s32:
 666 ; CHECK: mlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 667 ; CHECK-NEXT: ret
 668 entry:
 669   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
 670   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
 671   %sub = sub <2 x i64> %a, %vmull2.i
 672   ret <2 x i64> %sub
 673 }
 674
 675 define <4 x i32> @test_vmlsl_laneq_s16(<4 x i32> %a, <4 x i16> %b, <8 x i16> %v) {
 676 ; CHECK: test_vmlsl_laneq_s16:
 677 ; CHECK: mlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 678 ; CHECK-NEXT: ret
 679 entry:
 680   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
 681   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
 682   %sub = sub <4 x i32> %a, %vmull2.i
 683   ret <4 x i32> %sub
 684 }
 685
 686 define <2 x i64> @test_vmlsl_laneq_s32(<2 x i64> %a, <2 x i32> %b, <4 x i32> %v) {
 687 ; CHECK: test_vmlsl_laneq_s32:
 688 ; CHECK: mlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 689 ; CHECK-NEXT: ret
 690 entry:
 691   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
 692   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
 693   %sub = sub <2 x i64> %a, %vmull2.i
 694   ret <2 x i64> %sub
 695 }
 696
 697 define <4 x i32> @test_vmlsl_high_lane_s16(<4 x i32> %a, <8 x i16> %b, <4 x i16> %v) {
 698 ; CHECK: test_vmlsl_high_lane_s16:
 699 ; CHECK: mlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 700 ; CHECK-NEXT: ret
 701 entry:
 702   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
 703   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 704   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
 705   %sub = sub <4 x i32> %a, %vmull2.i
 706   ret <4 x i32> %sub
 707 }
 708
 709 define <2 x i64> @test_vmlsl_high_lane_s32(<2 x i64> %a, <4 x i32> %b, <2 x i32> %v) {
 710 ; CHECK: test_vmlsl_high_lane_s32:
 711 ; CHECK: mlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 712 ; CHECK-NEXT: ret
 713 entry:
 714   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
 715   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
 716   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
 717   %sub = sub <2 x i64> %a, %vmull2.i
 718   ret <2 x i64> %sub
 719 }
 720
 721 define <4 x i32> @test_vmlsl_high_laneq_s16(<4 x i32> %a, <8 x i16> %b, <8 x i16> %v) {
 722 ; CHECK: test_vmlsl_high_laneq_s16:
 723 ; CHECK: mlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 724 ; CHECK-NEXT: ret
 725 entry:
 726   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
 727   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
 728   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
 729   %sub = sub <4 x i32> %a, %vmull2.i
 730   ret <4 x i32> %sub
 731 }
 732
 733 define <2 x i64> @test_vmlsl_high_laneq_s32(<2 x i64> %a, <4 x i32> %b, <4 x i32> %v) {
 734 ; CHECK: test_vmlsl_high_laneq_s32:
 735 ; CHECK: mlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 736 ; CHECK-NEXT: ret
 737 entry:
 738   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
 739   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
 740   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
 741   %sub = sub <2 x i64> %a, %vmull2.i
 742   ret <2 x i64> %sub
 743 }
 744
 745 define <4 x i32> @test_vmlal_lane_u16(<4 x i32> %a, <4 x i16> %b, <4 x i16> %v) {
 746 ; CHECK: test_vmlal_lane_u16:
 747 ; CHECK: mlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 748 ; CHECK-NEXT: ret
 749 entry:
 750   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 751   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
 752   %add = add <4 x i32> %vmull2.i, %a
 753   ret <4 x i32> %add
 754 }
 755
 756 define <2 x i64> @test_vmlal_lane_u32(<2 x i64> %a, <2 x i32> %b, <2 x i32> %v) {
 757 ; CHECK: test_vmlal_lane_u32:
 758 ; CHECK: mlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 759 ; CHECK-NEXT: ret
 760 entry:
 761   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
 762   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
 763   %add = add <2 x i64> %vmull2.i, %a
 764   ret <2 x i64> %add
 765 }
 766
 767 define <4 x i32> @test_vmlal_laneq_u16(<4 x i32> %a, <4 x i16> %b, <8 x i16> %v) {
 768 ; CHECK: test_vmlal_laneq_u16:
 769 ; CHECK: mlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 770 ; CHECK-NEXT: ret
 771 entry:
 772   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
 773   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
 774   %add = add <4 x i32> %vmull2.i, %a
 775   ret <4 x i32> %add
 776 }
 777
 778 define <2 x i64> @test_vmlal_laneq_u32(<2 x i64> %a, <2 x i32> %b, <4 x i32> %v) {
 779 ; CHECK: test_vmlal_laneq_u32:
 780 ; CHECK: mlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 781 ; CHECK-NEXT: ret
 782 entry:
 783   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
 784   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
 785   %add = add <2 x i64> %vmull2.i, %a
 786   ret <2 x i64> %add
 787 }
 788
 789 define <4 x i32> @test_vmlal_high_lane_u16(<4 x i32> %a, <8 x i16> %b, <4 x i16> %v) {
 790 ; CHECK: test_vmlal_high_lane_u16:
 791 ; CHECK: mlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 792 ; CHECK-NEXT: ret
 793 entry:
 794   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
 795   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 796   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
 797   %add = add <4 x i32> %vmull2.i, %a
 798   ret <4 x i32> %add
 799 }
 800
 801 define <2 x i64> @test_vmlal_high_lane_u32(<2 x i64> %a, <4 x i32> %b, <2 x i32> %v) {
 802 ; CHECK: test_vmlal_high_lane_u32:
 803 ; CHECK: mlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 804 ; CHECK-NEXT: ret
 805 entry:
 806   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
 807   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
 808   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
 809   %add = add <2 x i64> %vmull2.i, %a
 810   ret <2 x i64> %add
 811 }
 812
 813 define <4 x i32> @test_vmlal_high_laneq_u16(<4 x i32> %a, <8 x i16> %b, <8 x i16> %v) {
 814 ; CHECK: test_vmlal_high_laneq_u16:
 815 ; CHECK: mlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 816 ; CHECK-NEXT: ret
 817 entry:
 818   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
 819   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
 820   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
 821   %add = add <4 x i32> %vmull2.i, %a
 822   ret <4 x i32> %add
 823 }
 824
 825 define <2 x i64> @test_vmlal_high_laneq_u32(<2 x i64> %a, <4 x i32> %b, <4 x i32> %v) {
 826 ; CHECK: test_vmlal_high_laneq_u32:
 827 ; CHECK: mlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 828 ; CHECK-NEXT: ret
 829 entry:
 830   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
 831   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
 832   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
 833   %add = add <2 x i64> %vmull2.i, %a
 834   ret <2 x i64> %add
 835 }
 836
 837 define <4 x i32> @test_vmlsl_lane_u16(<4 x i32> %a, <4 x i16> %b, <4 x i16> %v) {
 838 ; CHECK: test_vmlsl_lane_u16:
 839 ; CHECK: mlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 840 ; CHECK-NEXT: ret
 841 entry:
 842   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 843   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
 844   %sub = sub <4 x i32> %a, %vmull2.i
 845   ret <4 x i32> %sub
 846 }
 847
 848 define <2 x i64> @test_vmlsl_lane_u32(<2 x i64> %a, <2 x i32> %b, <2 x i32> %v) {
 849 ; CHECK: test_vmlsl_lane_u32:
 850 ; CHECK: mlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 851 ; CHECK-NEXT: ret
 852 entry:
 853   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
 854   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
 855   %sub = sub <2 x i64> %a, %vmull2.i
 856   ret <2 x i64> %sub
 857 }
 858
 859 define <4 x i32> @test_vmlsl_laneq_u16(<4 x i32> %a, <4 x i16> %b, <8 x i16> %v) {
 860 ; CHECK: test_vmlsl_laneq_u16:
 861 ; CHECK: mlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
 862 ; CHECK-NEXT: ret
 863 entry:
 864   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
 865   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
 866   %sub = sub <4 x i32> %a, %vmull2.i
 867   ret <4 x i32> %sub
 868 }
 869
 870 define <2 x i64> @test_vmlsl_laneq_u32(<2 x i64> %a, <2 x i32> %b, <4 x i32> %v) {
 871 ; CHECK: test_vmlsl_laneq_u32:
 872 ; CHECK: mlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
 873 ; CHECK-NEXT: ret
 874 entry:
 875   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
 876   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
 877   %sub = sub <2 x i64> %a, %vmull2.i
 878   ret <2 x i64> %sub
 879 }
 880
 881 define <4 x i32> @test_vmlsl_high_lane_u16(<4 x i32> %a, <8 x i16> %b, <4 x i16> %v) {
 882 ; CHECK: test_vmlsl_high_lane_u16:
 883 ; CHECK: mlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 884 ; CHECK-NEXT: ret
 885 entry:
 886   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
 887   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 888   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
 889   %sub = sub <4 x i32> %a, %vmull2.i
 890   ret <4 x i32> %sub
 891 }
 892
 893 define <2 x i64> @test_vmlsl_high_lane_u32(<2 x i64> %a, <4 x i32> %b, <2 x i32> %v) {
 894 ; CHECK: test_vmlsl_high_lane_u32:
 895 ; CHECK: mlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 896 ; CHECK-NEXT: ret
 897 entry:
 898   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
 899   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
 900   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
 901   %sub = sub <2 x i64> %a, %vmull2.i
 902   ret <2 x i64> %sub
 903 }
 904
 905 define <4 x i32> @test_vmlsl_high_laneq_u16(<4 x i32> %a, <8 x i16> %b, <8 x i16> %v) {
 906 ; CHECK: test_vmlsl_high_laneq_u16:
 907 ; CHECK: mlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
 908 ; CHECK-NEXT: ret
 909 entry:
 910   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
 911   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
 912   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
 913   %sub = sub <4 x i32> %a, %vmull2.i
 914   ret <4 x i32> %sub
 915 }
 916
 917 define <2 x i64> @test_vmlsl_high_laneq_u32(<2 x i64> %a, <4 x i32> %b, <4 x i32> %v) {
 918 ; CHECK: test_vmlsl_high_laneq_u32:
 919 ; CHECK: mlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
 920 ; CHECK-NEXT: ret
 921 entry:
 922   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
 923   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
 924   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
 925   %sub = sub <2 x i64> %a, %vmull2.i
 926   ret <2 x i64> %sub
 927 }
 928
 929 define <4 x i32> @test_vmull_lane_s16(<4 x i16> %a, <4 x i16> %v) {
 930 ; CHECK: test_vmull_lane_s16:
 931 ; CHECK: mull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 932 ; CHECK-NEXT: ret
 933 entry:
 934   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 935   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %a, <4 x i16> %shuffle)
 936   ret <4 x i32> %vmull2.i
 937 }
 938
 939 define <2 x i64> @test_vmull_lane_s32(<2 x i32> %a, <2 x i32> %v) {
 940 ; CHECK: test_vmull_lane_s32:
 941 ; CHECK: mull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 942 ; CHECK-NEXT: ret
 943 entry:
 944   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
 945   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %a, <2 x i32> %shuffle)
 946   ret <2 x i64> %vmull2.i
 947 }
 948
 949 define <4 x i32> @test_vmull_lane_u16(<4 x i16> %a, <4 x i16> %v) {
 950 ; CHECK: test_vmull_lane_u16:
 951 ; CHECK: mull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
 952 ; CHECK-NEXT: ret
 953 entry:
 954   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 955   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %a, <4 x i16> %shuffle)
 956   ret <4 x i32> %vmull2.i
 957 }
 958
 959 define <2 x i64> @test_vmull_lane_u32(<2 x i32> %a, <2 x i32> %v) {
 960 ; CHECK: test_vmull_lane_u32:
 961 ; CHECK: mull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
 962 ; CHECK-NEXT: ret
 963 entry:
 964   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
 965   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %a, <2 x i32> %shuffle)
 966   ret <2 x i64> %vmull2.i
 967 }
 968
 969 define <4 x i32> @test_vmull_high_lane_s16(<8 x i16> %a, <4 x i16> %v) {
 970 ; CHECK: test_vmull_high_lane_s16:
 971 ; CHECK: mull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 972 ; CHECK-NEXT: ret
 973 entry:
 974   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
 975   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 976   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
 977   ret <4 x i32> %vmull2.i
 978 }
 979
 980 define <2 x i64> @test_vmull_high_lane_s32(<4 x i32> %a, <2 x i32> %v) {
 981 ; CHECK: test_vmull_high_lane_s32:
 982 ; CHECK: mull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
 983 ; CHECK-NEXT: ret
 984 entry:
 985   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
 986   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
 987   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
 988   ret <2 x i64> %vmull2.i
 989 }
 990
 991 define <4 x i32> @test_vmull_high_lane_u16(<8 x i16> %a, <4 x i16> %v) {
 992 ; CHECK: test_vmull_high_lane_u16:
 993 ; CHECK: mull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
 994 ; CHECK-NEXT: ret
 995 entry:
 996   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
 997   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 998   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
 999   ret <4 x i32> %vmull2.i
1000 }
1001
1002 define <2 x i64> @test_vmull_high_lane_u32(<4 x i32> %a, <2 x i32> %v) {
1003 ; CHECK: test_vmull_high_lane_u32:
1004 ; CHECK: mull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
1005 ; CHECK-NEXT: ret
1006 entry:
1007   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
1008   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
1009   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
1010   ret <2 x i64> %vmull2.i
1011 }
1012
1013 define <4 x i32> @test_vmull_laneq_s16(<4 x i16> %a, <8 x i16> %v) {
1014 ; CHECK: test_vmull_laneq_s16:
1015 ; CHECK: mull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
1016 ; CHECK-NEXT: ret
1017 entry:
1018   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
1019   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %a, <4 x i16> %shuffle)
1020   ret <4 x i32> %vmull2.i
1021 }
1022
1023 define <2 x i64> @test_vmull_laneq_s32(<2 x i32> %a, <4 x i32> %v) {
1024 ; CHECK: test_vmull_laneq_s32:
1025 ; CHECK: mull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
1026 ; CHECK-NEXT: ret
1027 entry:
1028   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
1029   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %a, <2 x i32> %shuffle)
1030   ret <2 x i64> %vmull2.i
1031 }
1032
1033 define <4 x i32> @test_vmull_laneq_u16(<4 x i16> %a, <8 x i16> %v) {
1034 ; CHECK: test_vmull_laneq_u16:
1035 ; CHECK: mull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[7]
1036 ; CHECK-NEXT: ret
1037 entry:
1038   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
1039   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %a, <4 x i16> %shuffle)
1040   ret <4 x i32> %vmull2.i
1041 }
1042
1043 define <2 x i64> @test_vmull_laneq_u32(<2 x i32> %a, <4 x i32> %v) {
1044 ; CHECK: test_vmull_laneq_u32:
1045 ; CHECK: mull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
1046 ; CHECK-NEXT: ret
1047 entry:
1048   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
1049   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %a, <2 x i32> %shuffle)
1050   ret <2 x i64> %vmull2.i
1051 }
1052
1053 define <4 x i32> @test_vmull_high_laneq_s16(<8 x i16> %a, <8 x i16> %v) {
1054 ; CHECK: test_vmull_high_laneq_s16:
1055 ; CHECK: mull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
1056 ; CHECK-NEXT: ret
1057 entry:
1058   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1059   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
1060   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
1061   ret <4 x i32> %vmull2.i
1062 }
1063
1064 define <2 x i64> @test_vmull_high_laneq_s32(<4 x i32> %a, <4 x i32> %v) {
1065 ; CHECK: test_vmull_high_laneq_s32:
1066 ; CHECK: mull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
1067 ; CHECK-NEXT: ret
1068 entry:
1069   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
1070   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
1071   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
1072   ret <2 x i64> %vmull2.i
1073 }
1074
1075 define <4 x i32> @test_vmull_high_laneq_u16(<8 x i16> %a, <8 x i16> %v) {
1076 ; CHECK: test_vmull_high_laneq_u16:
1077 ; CHECK: mull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
1078 ; CHECK-NEXT: ret
1079 entry:
1080   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1081   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
1082   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
1083   ret <4 x i32> %vmull2.i
1084 }
1085
1086 define <2 x i64> @test_vmull_high_laneq_u32(<4 x i32> %a, <4 x i32> %v) {
1087 ; CHECK: test_vmull_high_laneq_u32:
1088 ; CHECK: mull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
1089 ; CHECK-NEXT: ret
1090 entry:
1091   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
1092   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
1093   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
1094   ret <2 x i64> %vmull2.i
1095 }
1096
1097 define <4 x i32> @test_vqdmlal_lane_s16(<4 x i32> %a, <4 x i16> %b, <4 x i16> %v) {
1098 ; CHECK: test_vqdmlal_lane_s16:
1099 ; CHECK: qdmlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
1100 ; CHECK-NEXT: ret
1101 entry:
1102   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
1103   %vqdmlal2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
1104   %vqdmlal4.i = tail call <4 x i32> @llvm.arm.neon.vqadds.v4i32(<4 x i32> %a, <4 x i32> %vqdmlal2.i)
1105   ret <4 x i32> %vqdmlal4.i
1106 }
1107
1108 define <2 x i64> @test_vqdmlal_lane_s32(<2 x i64> %a, <2 x i32> %b, <2 x i32> %v) {
1109 ; CHECK: test_vqdmlal_lane_s32:
1110 ; CHECK: qdmlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
1111 ; CHECK-NEXT: ret
1112 entry:
1113   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
1114   %vqdmlal2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
1115   %vqdmlal4.i = tail call <2 x i64> @llvm.arm.neon.vqadds.v2i64(<2 x i64> %a, <2 x i64> %vqdmlal2.i)
1116   ret <2 x i64> %vqdmlal4.i
1117 }
1118
1119 define <4 x i32> @test_vqdmlal_high_lane_s16(<4 x i32> %a, <8 x i16> %b, <4 x i16> %v) {
1120 ; CHECK: test_vqdmlal_high_lane_s16:
1121 ; CHECK: qdmlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
1122 ; CHECK-NEXT: ret
1123 entry:
1124   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1125   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
1126   %vqdmlal2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
1127   %vqdmlal4.i = tail call <4 x i32> @llvm.arm.neon.vqadds.v4i32(<4 x i32> %a, <4 x i32> %vqdmlal2.i)
1128   ret <4 x i32> %vqdmlal4.i
1129 }
1130
1131 define <2 x i64> @test_vqdmlal_high_lane_s32(<2 x i64> %a, <4 x i32> %b, <2 x i32> %v) {
1132 ; CHECK: test_vqdmlal_high_lane_s32:
1133 ; CHECK: qdmlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
1134 ; CHECK-NEXT: ret
1135 entry:
1136   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
1137   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
1138   %vqdmlal2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
1139   %vqdmlal4.i = tail call <2 x i64> @llvm.arm.neon.vqadds.v2i64(<2 x i64> %a, <2 x i64> %vqdmlal2.i)
1140   ret <2 x i64> %vqdmlal4.i
1141 }
1142
1143 define <4 x i32> @test_vqdmlsl_lane_s16(<4 x i32> %a, <4 x i16> %b, <4 x i16> %v) {
1144 ; CHECK: test_vqdmlsl_lane_s16:
1145 ; CHECK: qdmlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
1146 ; CHECK-NEXT: ret
1147 entry:
1148   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
1149   %vqdmlsl2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
1150   %vqdmlsl4.i = tail call <4 x i32> @llvm.arm.neon.vqsubs.v4i32(<4 x i32> %a, <4 x i32> %vqdmlsl2.i)
1151   ret <4 x i32> %vqdmlsl4.i
1152 }
1153
1154 define <2 x i64> @test_vqdmlsl_lane_s32(<2 x i64> %a, <2 x i32> %b, <2 x i32> %v) {
1155 ; CHECK: test_vqdmlsl_lane_s32:
1156 ; CHECK: qdmlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
1157 ; CHECK-NEXT: ret
1158 entry:
1159   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
1160   %vqdmlsl2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
1161   %vqdmlsl4.i = tail call <2 x i64> @llvm.arm.neon.vqsubs.v2i64(<2 x i64> %a, <2 x i64> %vqdmlsl2.i)
1162   ret <2 x i64> %vqdmlsl4.i
1163 }
1164
1165 define <4 x i32> @test_vqdmlsl_high_lane_s16(<4 x i32> %a, <8 x i16> %b, <4 x i16> %v) {
1166 ; CHECK: test_vqdmlsl_high_lane_s16:
1167 ; CHECK: qdmlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
1168 ; CHECK-NEXT: ret
1169 entry:
1170   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1171   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
1172   %vqdmlsl2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
1173   %vqdmlsl4.i = tail call <4 x i32> @llvm.arm.neon.vqsubs.v4i32(<4 x i32> %a, <4 x i32> %vqdmlsl2.i)
1174   ret <4 x i32> %vqdmlsl4.i
1175 }
1176
1177 define <2 x i64> @test_vqdmlsl_high_lane_s32(<2 x i64> %a, <4 x i32> %b, <2 x i32> %v) {
1178 ; CHECK: test_vqdmlsl_high_lane_s32:
1179 ; CHECK: qdmlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
1180 ; CHECK-NEXT: ret
1181 entry:
1182   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
1183   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
1184   %vqdmlsl2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
1185   %vqdmlsl4.i = tail call <2 x i64> @llvm.arm.neon.vqsubs.v2i64(<2 x i64> %a, <2 x i64> %vqdmlsl2.i)
1186   ret <2 x i64> %vqdmlsl4.i
1187 }
1188
1189 define <4 x i32> @test_vqdmull_lane_s16(<4 x i16> %a, <4 x i16> %v) {
1190 ; CHECK: test_vqdmull_lane_s16:
1191 ; CHECK: qdmull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
1192 ; CHECK-NEXT: ret
1193 entry:
1194   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
1195   %vqdmull2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %a, <4 x i16> %shuffle)
1196   ret <4 x i32> %vqdmull2.i
1197 }
1198
1199 define <2 x i64> @test_vqdmull_lane_s32(<2 x i32> %a, <2 x i32> %v) {
1200 ; CHECK: test_vqdmull_lane_s32:
1201 ; CHECK: qdmull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
1202 ; CHECK-NEXT: ret
1203 entry:
1204   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
1205   %vqdmull2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %a, <2 x i32> %shuffle)
1206   ret <2 x i64> %vqdmull2.i
1207 }
1208
1209 define <4 x i32> @test_vqdmull_laneq_s16(<4 x i16> %a, <8 x i16> %v) {
1210 ; CHECK: test_vqdmull_laneq_s16:
1211 ; CHECK: qdmull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
1212 ; CHECK-NEXT: ret
1213 entry:
1214   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
1215   %vqdmull2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %a, <4 x i16> %shuffle)
1216   ret <4 x i32> %vqdmull2.i
1217 }
1218
1219 define <2 x i64> @test_vqdmull_laneq_s32(<2 x i32> %a, <4 x i32> %v) {
1220 ; CHECK: test_vqdmull_laneq_s32:
1221 ; CHECK: qdmull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
1222 ; CHECK-NEXT: ret
1223 entry:
1224   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
1225   %vqdmull2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %a, <2 x i32> %shuffle)
1226   ret <2 x i64> %vqdmull2.i
1227 }
1228
1229 define <4 x i32> @test_vqdmull_high_lane_s16(<8 x i16> %a, <4 x i16> %v) {
1230 ; CHECK: test_vqdmull_high_lane_s16:
1231 ; CHECK: qdmull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
1232 ; CHECK-NEXT: ret
1233 entry:
1234   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1235   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
1236   %vqdmull2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
1237   ret <4 x i32> %vqdmull2.i
1238 }
1239
1240 define <2 x i64> @test_vqdmull_high_lane_s32(<4 x i32> %a, <2 x i32> %v) {
1241 ; CHECK: test_vqdmull_high_lane_s32:
1242 ; CHECK: qdmull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
1243 ; CHECK-NEXT: ret
1244 entry:
1245   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
1246   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
1247   %vqdmull2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
1248   ret <2 x i64> %vqdmull2.i
1249 }
1250
1251 define <4 x i32> @test_vqdmull_high_laneq_s16(<8 x i16> %a, <8 x i16> %v) {
1252 ; CHECK: test_vqdmull_high_laneq_s16:
1253 ; CHECK: qdmull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[7]
1254 ; CHECK-NEXT: ret
1255 entry:
1256   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1257   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> <i32 7, i32 7, i32 7, i32 7>
1258   %vqdmull2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
1259   ret <4 x i32> %vqdmull2.i
1260 }
1261
1262 define <2 x i64> @test_vqdmull_high_laneq_s32(<4 x i32> %a, <4 x i32> %v) {
1263 ; CHECK: test_vqdmull_high_laneq_s32:
1264 ; CHECK: qdmull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
1265 ; CHECK-NEXT: ret
1266 entry:
1267   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
1268   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> <i32 3, i32 3>
1269   %vqdmull2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
1270   ret <2 x i64> %vqdmull2.i
1271 }
1272
1273 define <4 x i16> @test_vqdmulh_lane_s16(<4 x i16> %a, <4 x i16> %v) {
1274 ; CHECK: test_vqdmulh_lane_s16:
1275 ; CHECK: qdmulh {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
1276 ; CHECK-NEXT: ret
1277 entry:
1278   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
1279   %vqdmulh2.i = tail call <4 x i16> @llvm.arm.neon.vqdmulh.v4i16(<4 x i16> %a, <4 x i16> %shuffle)
1280   ret <4 x i16> %vqdmulh2.i
1281 }
1282
1283 define <8 x i16> @test_vqdmulhq_lane_s16(<8 x i16> %a, <4 x i16> %v) {
1284 ; CHECK: test_vqdmulhq_lane_s16:
1285 ; CHECK: qdmulh {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
1286 ; CHECK-NEXT: ret
1287 entry:
1288   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <8 x i32> <i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3>
1289   %vqdmulh2.i = tail call <8 x i16> @llvm.arm.neon.vqdmulh.v8i16(<8 x i16> %a, <8 x i16> %shuffle)
1290   ret <8 x i16> %vqdmulh2.i
1291 }
1292
1293 define <2 x i32> @test_vqdmulh_lane_s32(<2 x i32> %a, <2 x i32> %v) {
1294 ; CHECK: test_vqdmulh_lane_s32:
1295 ; CHECK: qdmulh {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
1296 ; CHECK-NEXT: ret
1297 entry:
1298   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
1299   %vqdmulh2.i = tail call <2 x i32> @llvm.arm.neon.vqdmulh.v2i32(<2 x i32> %a, <2 x i32> %shuffle)
1300   ret <2 x i32> %vqdmulh2.i
1301 }
1302
1303 define <4 x i32> @test_vqdmulhq_lane_s32(<4 x i32> %a, <2 x i32> %v) {
1304 ; CHECK: test_vqdmulhq_lane_s32:
1305 ; CHECK: qdmulh {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
1306 ; CHECK-NEXT: ret
1307 entry:
1308   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
1309   %vqdmulh2.i = tail call <4 x i32> @llvm.arm.neon.vqdmulh.v4i32(<4 x i32> %a, <4 x i32> %shuffle)
1310   ret <4 x i32> %vqdmulh2.i
1311 }
1312
1313 define <4 x i16> @test_vqrdmulh_lane_s16(<4 x i16> %a, <4 x i16> %v) {
1314 ; CHECK: test_vqrdmulh_lane_s16:
1315 ; CHECK: qrdmulh {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[3]
1316 ; CHECK-NEXT: ret
1317 entry:
1318   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
1319   %vqrdmulh2.i = tail call <4 x i16> @llvm.arm.neon.vqrdmulh.v4i16(<4 x i16> %a, <4 x i16> %shuffle)
1320   ret <4 x i16> %vqrdmulh2.i
1321 }
1322
1323 define <8 x i16> @test_vqrdmulhq_lane_s16(<8 x i16> %a, <4 x i16> %v) {
1324 ; CHECK: test_vqrdmulhq_lane_s16:
1325 ; CHECK: qrdmulh {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[3]
1326 ; CHECK-NEXT: ret
1327 entry:
1328   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <8 x i32> <i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3, i32 3>
1329   %vqrdmulh2.i = tail call <8 x i16> @llvm.arm.neon.vqrdmulh.v8i16(<8 x i16> %a, <8 x i16> %shuffle)
1330   ret <8 x i16> %vqrdmulh2.i
1331 }
1332
1333 define <2 x i32> @test_vqrdmulh_lane_s32(<2 x i32> %a, <2 x i32> %v) {
1334 ; CHECK: test_vqrdmulh_lane_s32:
1335 ; CHECK: qrdmulh {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
1336 ; CHECK-NEXT: ret
1337 entry:
1338   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> <i32 1, i32 1>
1339   %vqrdmulh2.i = tail call <2 x i32> @llvm.arm.neon.vqrdmulh.v2i32(<2 x i32> %a, <2 x i32> %shuffle)
1340   ret <2 x i32> %vqrdmulh2.i
1341 }
1342
1343 define <4 x i32> @test_vqrdmulhq_lane_s32(<4 x i32> %a, <2 x i32> %v) {
1344 ; CHECK: test_vqrdmulhq_lane_s32:
1345 ; CHECK: qrdmulh {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
1346 ; CHECK-NEXT: ret
1347 entry:
1348   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
1349   %vqrdmulh2.i = tail call <4 x i32> @llvm.arm.neon.vqrdmulh.v4i32(<4 x i32> %a, <4 x i32> %shuffle)
1350   ret <4 x i32> %vqrdmulh2.i
1351 }
1352
1353 define <2 x float> @test_vmul_lane_f32(<2 x float> %a, <2 x float> %v) {
1354 ; CHECK: test_vmul_lane_f32:
1355 ; CHECK: fmul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
1356 ; CHECK-NEXT: ret
1357 entry:
1358   %shuffle = shufflevector <2 x float> %v, <2 x float> undef, <2 x i32> <i32 1, i32 1>
1359   %mul = fmul <2 x float> %shuffle, %a
1360   ret <2 x float> %mul
1361 }
1362
1363 define <1 x double> @test_vmul_lane_f64(<1 x double> %a, <1 x double> %v) {
1364 ; CHECK: test_vmul_lane_f64:
1365 ; CHECK: fmul {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
1366 ; CHECK-NEXT: ret
1367 entry:
1368   %0 = bitcast <1 x double> %a to <8 x i8>
1369   %1 = bitcast <8 x i8> %0 to double
1370   %extract = extractelement <1 x double> %v, i32 0
1371   %2 = fmul double %1, %extract
1372   %3 = insertelement <1 x double> undef, double %2, i32 0
1373   ret <1 x double> %3
1374 }
1375
1376 define <4 x float> @test_vmulq_lane_f32(<4 x float> %a, <2 x float> %v) {
1377 ; CHECK: test_vmulq_lane_f32:
1378 ; CHECK: fmul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
1379 ; CHECK-NEXT: ret
1380 entry:
1381   %shuffle = shufflevector <2 x float> %v, <2 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
1382   %mul = fmul <4 x float> %shuffle, %a
1383   ret <4 x float> %mul
1384 }
1385
1386 define <2 x double> @test_vmulq_lane_f64(<2 x double> %a, <1 x double> %v) {
1387 ; CHECK: test_vmulq_lane_f64:
1388 ; CHECK: fmul {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
1389 ; CHECK-NEXT: ret
1390 entry:
1391   %shuffle = shufflevector <1 x double> %v, <1 x double> undef, <2 x i32> zeroinitializer
1392   %mul = fmul <2 x double> %shuffle, %a
1393   ret <2 x double> %mul
1394 }
1395
1396 define <2 x float> @test_vmul_laneq_f32(<2 x float> %a, <4 x float> %v) {
1397 ; CHECK: test_vmul_laneq_f32:
1398 ; CHECK: fmul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
1399 ; CHECK-NEXT: ret
1400 entry:
1401   %shuffle = shufflevector <4 x float> %v, <4 x float> undef, <2 x i32> <i32 3, i32 3>
1402   %mul = fmul <2 x float> %shuffle, %a
1403   ret <2 x float> %mul
1404 }
1405
1406 define <1 x double> @test_vmul_laneq_f64(<1 x double> %a, <2 x double> %v) {
1407 ; CHECK: test_vmul_laneq_f64:
1408 ; CHECK: fmul {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[1]
1409 ; CHECK-NEXT: ret
1410 entry:
1411   %0 = bitcast <1 x double> %a to <8 x i8>
1412   %1 = bitcast <8 x i8> %0 to double
1413   %extract = extractelement <2 x double> %v, i32 1
1414   %2 = fmul double %1, %extract
1415   %3 = insertelement <1 x double> undef, double %2, i32 0
1416   ret <1 x double> %3
1417 }
1418
1419 define <4 x float> @test_vmulq_laneq_f32(<4 x float> %a, <4 x float> %v) {
1420 ; CHECK: test_vmulq_laneq_f32:
1421 ; CHECK: fmul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
1422 ; CHECK-NEXT: ret
1423 entry:
1424   %shuffle = shufflevector <4 x float> %v, <4 x float> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
1425   %mul = fmul <4 x float> %shuffle, %a
1426   ret <4 x float> %mul
1427 }
1428
1429 define <2 x double> @test_vmulq_laneq_f64(<2 x double> %a, <2 x double> %v) {
1430 ; CHECK: test_vmulq_laneq_f64:
1431 ; CHECK: fmul {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[1]
1432 ; CHECK-NEXT: ret
1433 entry:
1434   %shuffle = shufflevector <2 x double> %v, <2 x double> undef, <2 x i32> <i32 1, i32 1>
1435   %mul = fmul <2 x double> %shuffle, %a
1436   ret <2 x double> %mul
1437 }
1438
1439 define <2 x float> @test_vmulx_lane_f32(<2 x float> %a, <2 x float> %v) {
1440 ; CHECK: test_vmulx_lane_f32:
1441 ; CHECK: mulx {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[1]
1442 ; CHECK-NEXT: ret
1443 entry:
1444   %shuffle = shufflevector <2 x float> %v, <2 x float> undef, <2 x i32> <i32 1, i32 1>
1445   %vmulx2.i = tail call <2 x float> @llvm.aarch64.neon.vmulx.v2f32(<2 x float> %a, <2 x float> %shuffle)
1446   ret <2 x float> %vmulx2.i
1447 }
1448
1449 define <4 x float> @test_vmulxq_lane_f32(<4 x float> %a, <2 x float> %v) {
1450 ; CHECK: test_vmulxq_lane_f32:
1451 ; CHECK: mulx {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[1]
1452 ; CHECK-NEXT: ret
1453 entry:
1454   %shuffle = shufflevector <2 x float> %v, <2 x float> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
1455   %vmulx2.i = tail call <4 x float> @llvm.aarch64.neon.vmulx.v4f32(<4 x float> %a, <4 x float> %shuffle)
1456   ret <4 x float> %vmulx2.i
1457 }
1458
1459 define <2 x double> @test_vmulxq_lane_f64(<2 x double> %a, <1 x double> %v) {
1460 ; CHECK: test_vmulxq_lane_f64:
1461 ; CHECK: mulx {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
1462 ; CHECK-NEXT: ret
1463 entry:
1464   %shuffle = shufflevector <1 x double> %v, <1 x double> undef, <2 x i32> zeroinitializer
1465   %vmulx2.i = tail call <2 x double> @llvm.aarch64.neon.vmulx.v2f64(<2 x double> %a, <2 x double> %shuffle)
1466   ret <2 x double> %vmulx2.i
1467 }
1468
1469 define <2 x float> @test_vmulx_laneq_f32(<2 x float> %a, <4 x float> %v) {
1470 ; CHECK: test_vmulx_laneq_f32:
1471 ; CHECK: mulx {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[3]
1472 ; CHECK-NEXT: ret
1473 entry:
1474   %shuffle = shufflevector <4 x float> %v, <4 x float> undef, <2 x i32> <i32 3, i32 3>
1475   %vmulx2.i = tail call <2 x float> @llvm.aarch64.neon.vmulx.v2f32(<2 x float> %a, <2 x float> %shuffle)
1476   ret <2 x float> %vmulx2.i
1477 }
1478
1479 define <4 x float> @test_vmulxq_laneq_f32(<4 x float> %a, <4 x float> %v) {
1480 ; CHECK: test_vmulxq_laneq_f32:
1481 ; CHECK: mulx {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[3]
1482 ; CHECK-NEXT: ret
1483 entry:
1484   %shuffle = shufflevector <4 x float> %v, <4 x float> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
1485   %vmulx2.i = tail call <4 x float> @llvm.aarch64.neon.vmulx.v4f32(<4 x float> %a, <4 x float> %shuffle)
1486   ret <4 x float> %vmulx2.i
1487 }
1488
1489 define <2 x double> @test_vmulxq_laneq_f64(<2 x double> %a, <2 x double> %v) {
1490 ; CHECK: test_vmulxq_laneq_f64:
1491 ; CHECK: mulx {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[1]
1492 ; CHECK-NEXT: ret
1493 entry:
1494   %shuffle = shufflevector <2 x double> %v, <2 x double> undef, <2 x i32> <i32 1, i32 1>
1495   %vmulx2.i = tail call <2 x double> @llvm.aarch64.neon.vmulx.v2f64(<2 x double> %a, <2 x double> %shuffle)
1496   ret <2 x double> %vmulx2.i
1497 }
1498
1499 define <4 x i16> @test_vmla_lane_s16_0(<4 x i16> %a, <4 x i16> %b, <4 x i16> %v) {
1500 ; CHECK: test_vmla_lane_s16_0:
1501 ; CHECK: mla {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
1502 ; CHECK-NEXT: ret
1503 entry:
1504   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
1505   %mul = mul <4 x i16> %shuffle, %b
1506   %add = add <4 x i16> %mul, %a
1507   ret <4 x i16> %add
1508 }
1509
1510 define <8 x i16> @test_vmlaq_lane_s16_0(<8 x i16> %a, <8 x i16> %b, <4 x i16> %v) {
1511 ; CHECK: test_vmlaq_lane_s16_0:
1512 ; CHECK: mla {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
1513 ; CHECK-NEXT: ret
1514 entry:
1515   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <8 x i32> zeroinitializer
1516   %mul = mul <8 x i16> %shuffle, %b
1517   %add = add <8 x i16> %mul, %a
1518   ret <8 x i16> %add
1519 }
1520
1521 define <2 x i32> @test_vmla_lane_s32_0(<2 x i32> %a, <2 x i32> %b, <2 x i32> %v) {
1522 ; CHECK: test_vmla_lane_s32_0:
1523 ; CHECK: mla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
1524 ; CHECK-NEXT: ret
1525 entry:
1526   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
1527   %mul = mul <2 x i32> %shuffle, %b
1528   %add = add <2 x i32> %mul, %a
1529   ret <2 x i32> %add
1530 }
1531
1532 define <4 x i32> @test_vmlaq_lane_s32_0(<4 x i32> %a, <4 x i32> %b, <2 x i32> %v) {
1533 ; CHECK: test_vmlaq_lane_s32_0:
1534 ; CHECK: mla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
1535 ; CHECK-NEXT: ret
1536 entry:
1537   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <4 x i32> zeroinitializer
1538   %mul = mul <4 x i32> %shuffle, %b
1539   %add = add <4 x i32> %mul, %a
1540   ret <4 x i32> %add
1541 }
1542
1543 define <4 x i16> @test_vmla_laneq_s16_0(<4 x i16> %a, <4 x i16> %b, <8 x i16> %v) {
1544 ; CHECK: test_vmla_laneq_s16_0:
1545 ; CHECK: mla {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
1546 ; CHECK-NEXT: ret
1547 entry:
1548   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
1549   %mul = mul <4 x i16> %shuffle, %b
1550   %add = add <4 x i16> %mul, %a
1551   ret <4 x i16> %add
1552 }
1553
1554 define <8 x i16> @test_vmlaq_laneq_s16_0(<8 x i16> %a, <8 x i16> %b, <8 x i16> %v) {
1555 ; CHECK: test_vmlaq_laneq_s16_0:
1556 ; CHECK: mla {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
1557 ; CHECK-NEXT: ret
1558 entry:
1559   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <8 x i32> zeroinitializer
1560   %mul = mul <8 x i16> %shuffle, %b
1561   %add = add <8 x i16> %mul, %a
1562   ret <8 x i16> %add
1563 }
1564
1565 define <2 x i32> @test_vmla_laneq_s32_0(<2 x i32> %a, <2 x i32> %b, <4 x i32> %v) {
1566 ; CHECK: test_vmla_laneq_s32_0:
1567 ; CHECK: mla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
1568 ; CHECK-NEXT: ret
1569 entry:
1570   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
1571   %mul = mul <2 x i32> %shuffle, %b
1572   %add = add <2 x i32> %mul, %a
1573   ret <2 x i32> %add
1574 }
1575
1576 define <4 x i32> @test_vmlaq_laneq_s32_0(<4 x i32> %a, <4 x i32> %b, <4 x i32> %v) {
1577 ; CHECK: test_vmlaq_laneq_s32_0:
1578 ; CHECK: mla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
1579 ; CHECK-NEXT: ret
1580 entry:
1581   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <4 x i32> zeroinitializer
1582   %mul = mul <4 x i32> %shuffle, %b
1583   %add = add <4 x i32> %mul, %a
1584   ret <4 x i32> %add
1585 }
1586
1587 define <4 x i16> @test_vmls_lane_s16_0(<4 x i16> %a, <4 x i16> %b, <4 x i16> %v) {
1588 ; CHECK: test_vmls_lane_s16_0:
1589 ; CHECK: mls {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
1590 ; CHECK-NEXT: ret
1591 entry:
1592   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
1593   %mul = mul <4 x i16> %shuffle, %b
1594   %sub = sub <4 x i16> %a, %mul
1595   ret <4 x i16> %sub
1596 }
1597
1598 define <8 x i16> @test_vmlsq_lane_s16_0(<8 x i16> %a, <8 x i16> %b, <4 x i16> %v) {
1599 ; CHECK: test_vmlsq_lane_s16_0:
1600 ; CHECK: mls {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
1601 ; CHECK-NEXT: ret
1602 entry:
1603   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <8 x i32> zeroinitializer
1604   %mul = mul <8 x i16> %shuffle, %b
1605   %sub = sub <8 x i16> %a, %mul
1606   ret <8 x i16> %sub
1607 }
1608
1609 define <2 x i32> @test_vmls_lane_s32_0(<2 x i32> %a, <2 x i32> %b, <2 x i32> %v) {
1610 ; CHECK: test_vmls_lane_s32_0:
1611 ; CHECK: mls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
1612 ; CHECK-NEXT: ret
1613 entry:
1614   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
1615   %mul = mul <2 x i32> %shuffle, %b
1616   %sub = sub <2 x i32> %a, %mul
1617   ret <2 x i32> %sub
1618 }
1619
1620 define <4 x i32> @test_vmlsq_lane_s32_0(<4 x i32> %a, <4 x i32> %b, <2 x i32> %v) {
1621 ; CHECK: test_vmlsq_lane_s32_0:
1622 ; CHECK: mls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
1623 ; CHECK-NEXT: ret
1624 entry:
1625   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <4 x i32> zeroinitializer
1626   %mul = mul <4 x i32> %shuffle, %b
1627   %sub = sub <4 x i32> %a, %mul
1628   ret <4 x i32> %sub
1629 }
1630
1631 define <4 x i16> @test_vmls_laneq_s16_0(<4 x i16> %a, <4 x i16> %b, <8 x i16> %v) {
1632 ; CHECK: test_vmls_laneq_s16_0:
1633 ; CHECK: mls {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
1634 ; CHECK-NEXT: ret
1635 entry:
1636   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
1637   %mul = mul <4 x i16> %shuffle, %b
1638   %sub = sub <4 x i16> %a, %mul
1639   ret <4 x i16> %sub
1640 }
1641
1642 define <8 x i16> @test_vmlsq_laneq_s16_0(<8 x i16> %a, <8 x i16> %b, <8 x i16> %v) {
1643 ; CHECK: test_vmlsq_laneq_s16_0:
1644 ; CHECK: mls {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
1645 ; CHECK-NEXT: ret
1646 entry:
1647   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <8 x i32> zeroinitializer
1648   %mul = mul <8 x i16> %shuffle, %b
1649   %sub = sub <8 x i16> %a, %mul
1650   ret <8 x i16> %sub
1651 }
1652
1653 define <2 x i32> @test_vmls_laneq_s32_0(<2 x i32> %a, <2 x i32> %b, <4 x i32> %v) {
1654 ; CHECK: test_vmls_laneq_s32_0:
1655 ; CHECK: mls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
1656 ; CHECK-NEXT: ret
1657 entry:
1658   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
1659   %mul = mul <2 x i32> %shuffle, %b
1660   %sub = sub <2 x i32> %a, %mul
1661   ret <2 x i32> %sub
1662 }
1663
1664 define <4 x i32> @test_vmlsq_laneq_s32_0(<4 x i32> %a, <4 x i32> %b, <4 x i32> %v) {
1665 ; CHECK: test_vmlsq_laneq_s32_0:
1666 ; CHECK: mls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
1667 ; CHECK-NEXT: ret
1668 entry:
1669   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <4 x i32> zeroinitializer
1670   %mul = mul <4 x i32> %shuffle, %b
1671   %sub = sub <4 x i32> %a, %mul
1672   ret <4 x i32> %sub
1673 }
1674
1675 define <4 x i16> @test_vmul_lane_s16_0(<4 x i16> %a, <4 x i16> %v) {
1676 ; CHECK: test_vmul_lane_s16_0:
1677 ; CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
1678 ; CHECK-NEXT: ret
1679 entry:
1680   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
1681   %mul = mul <4 x i16> %shuffle, %a
1682   ret <4 x i16> %mul
1683 }
1684
1685 define <8 x i16> @test_vmulq_lane_s16_0(<8 x i16> %a, <4 x i16> %v) {
1686 ; CHECK: test_vmulq_lane_s16_0:
1687 ; CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
1688 ; CHECK-NEXT: ret
1689 entry:
1690   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <8 x i32> zeroinitializer
1691   %mul = mul <8 x i16> %shuffle, %a
1692   ret <8 x i16> %mul
1693 }
1694
1695 define <2 x i32> @test_vmul_lane_s32_0(<2 x i32> %a, <2 x i32> %v) {
1696 ; CHECK: test_vmul_lane_s32_0:
1697 ; CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
1698 ; CHECK-NEXT: ret
1699 entry:
1700   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
1701   %mul = mul <2 x i32> %shuffle, %a
1702   ret <2 x i32> %mul
1703 }
1704
1705 define <4 x i32> @test_vmulq_lane_s32_0(<4 x i32> %a, <2 x i32> %v) {
1706 ; CHECK: test_vmulq_lane_s32_0:
1707 ; CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
1708 ; CHECK-NEXT: ret
1709 entry:
1710   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <4 x i32> zeroinitializer
1711   %mul = mul <4 x i32> %shuffle, %a
1712   ret <4 x i32> %mul
1713 }
1714
1715 define <4 x i16> @test_vmul_lane_u16_0(<4 x i16> %a, <4 x i16> %v) {
1716 ; CHECK: test_vmul_lane_u16_0:
1717 ; CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
1718 ; CHECK-NEXT: ret
1719 entry:
1720   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
1721   %mul = mul <4 x i16> %shuffle, %a
1722   ret <4 x i16> %mul
1723 }
1724
1725 define <8 x i16> @test_vmulq_lane_u16_0(<8 x i16> %a, <4 x i16> %v) {
1726 ; CHECK: test_vmulq_lane_u16_0:
1727 ; CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
1728 ; CHECK-NEXT: ret
1729 entry:
1730   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <8 x i32> zeroinitializer
1731   %mul = mul <8 x i16> %shuffle, %a
1732   ret <8 x i16> %mul
1733 }
1734
1735 define <2 x i32> @test_vmul_lane_u32_0(<2 x i32> %a, <2 x i32> %v) {
1736 ; CHECK: test_vmul_lane_u32_0:
1737 ; CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
1738 ; CHECK-NEXT: ret
1739 entry:
1740   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
1741   %mul = mul <2 x i32> %shuffle, %a
1742   ret <2 x i32> %mul
1743 }
1744
1745 define <4 x i32> @test_vmulq_lane_u32_0(<4 x i32> %a, <2 x i32> %v) {
1746 ; CHECK: test_vmulq_lane_u32_0:
1747 ; CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
1748 ; CHECK-NEXT: ret
1749 entry:
1750   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <4 x i32> zeroinitializer
1751   %mul = mul <4 x i32> %shuffle, %a
1752   ret <4 x i32> %mul
1753 }
1754
1755 define <4 x i16> @test_vmul_laneq_s16_0(<4 x i16> %a, <8 x i16> %v) {
1756 ; CHECK: test_vmul_laneq_s16_0:
1757 ; CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
1758 ; CHECK-NEXT: ret
1759 entry:
1760   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
1761   %mul = mul <4 x i16> %shuffle, %a
1762   ret <4 x i16> %mul
1763 }
1764
1765 define <8 x i16> @test_vmulq_laneq_s16_0(<8 x i16> %a, <8 x i16> %v) {
1766 ; CHECK: test_vmulq_laneq_s16_0:
1767 ; CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
1768 ; CHECK-NEXT: ret
1769 entry:
1770   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <8 x i32> zeroinitializer
1771   %mul = mul <8 x i16> %shuffle, %a
1772   ret <8 x i16> %mul
1773 }
1774
1775 define <2 x i32> @test_vmul_laneq_s32_0(<2 x i32> %a, <4 x i32> %v) {
1776 ; CHECK: test_vmul_laneq_s32_0:
1777 ; CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
1778 ; CHECK-NEXT: ret
1779 entry:
1780   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
1781   %mul = mul <2 x i32> %shuffle, %a
1782   ret <2 x i32> %mul
1783 }
1784
1785 define <4 x i32> @test_vmulq_laneq_s32_0(<4 x i32> %a, <4 x i32> %v) {
1786 ; CHECK: test_vmulq_laneq_s32_0:
1787 ; CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
1788 ; CHECK-NEXT: ret
1789 entry:
1790   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <4 x i32> zeroinitializer
1791   %mul = mul <4 x i32> %shuffle, %a
1792   ret <4 x i32> %mul
1793 }
1794
1795 define <4 x i16> @test_vmul_laneq_u16_0(<4 x i16> %a, <8 x i16> %v) {
1796 ; CHECK: test_vmul_laneq_u16_0:
1797 ; CHECK: mul {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
1798 ; CHECK-NEXT: ret
1799 entry:
1800   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
1801   %mul = mul <4 x i16> %shuffle, %a
1802   ret <4 x i16> %mul
1803 }
1804
1805 define <8 x i16> @test_vmulq_laneq_u16_0(<8 x i16> %a, <8 x i16> %v) {
1806 ; CHECK: test_vmulq_laneq_u16_0:
1807 ; CHECK: mul {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
1808 ; CHECK-NEXT: ret
1809 entry:
1810   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <8 x i32> zeroinitializer
1811   %mul = mul <8 x i16> %shuffle, %a
1812   ret <8 x i16> %mul
1813 }
1814
1815 define <2 x i32> @test_vmul_laneq_u32_0(<2 x i32> %a, <4 x i32> %v) {
1816 ; CHECK: test_vmul_laneq_u32_0:
1817 ; CHECK: mul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
1818 ; CHECK-NEXT: ret
1819 entry:
1820   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
1821   %mul = mul <2 x i32> %shuffle, %a
1822   ret <2 x i32> %mul
1823 }
1824
1825 define <4 x i32> @test_vmulq_laneq_u32_0(<4 x i32> %a, <4 x i32> %v) {
1826 ; CHECK: test_vmulq_laneq_u32_0:
1827 ; CHECK: mul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
1828 ; CHECK-NEXT: ret
1829 entry:
1830   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <4 x i32> zeroinitializer
1831   %mul = mul <4 x i32> %shuffle, %a
1832   ret <4 x i32> %mul
1833 }
1834
1835 define <2 x float> @test_vfma_lane_f32_0(<2 x float> %a, <2 x float> %b, <2 x float> %v) {
1836 ; CHECK: test_vfma_lane_f32_0:
1837 ; CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
1838 ; CHECK-NEXT: ret
1839 entry:
1840   %lane = shufflevector <2 x float> %v, <2 x float> undef, <2 x i32> zeroinitializer
1841   %0 = tail call <2 x float> @llvm.fma.v2f32(<2 x float> %lane, <2 x float> %b, <2 x float> %a)
1842   ret <2 x float> %0
1843 }
1844
1845 define <4 x float> @test_vfmaq_lane_f32_0(<4 x float> %a, <4 x float> %b, <2 x float> %v) {
1846 ; CHECK: test_vfmaq_lane_f32_0:
1847 ; CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
1848 ; CHECK-NEXT: ret
1849 entry:
1850   %lane = shufflevector <2 x float> %v, <2 x float> undef, <4 x i32> zeroinitializer
1851   %0 = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %lane, <4 x float> %b, <4 x float> %a)
1852   ret <4 x float> %0
1853 }
1854
1855 define <2 x float> @test_vfma_laneq_f32_0(<2 x float> %a, <2 x float> %b, <4 x float> %v) {
1856 ; CHECK: test_vfma_laneq_f32_0:
1857 ; CHECK: fmla {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
1858 ; CHECK-NEXT: ret
1859 entry:
1860   %lane = shufflevector <4 x float> %v, <4 x float> undef, <2 x i32> zeroinitializer
1861   %0 = tail call <2 x float> @llvm.fma.v2f32(<2 x float> %lane, <2 x float> %b, <2 x float> %a)
1862   ret <2 x float> %0
1863 }
1864
1865 define <4 x float> @test_vfmaq_laneq_f32_0(<4 x float> %a, <4 x float> %b, <4 x float> %v) {
1866 ; CHECK: test_vfmaq_laneq_f32_0:
1867 ; CHECK: fmla {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
1868 ; CHECK-NEXT: ret
1869 entry:
1870   %lane = shufflevector <4 x float> %v, <4 x float> undef, <4 x i32> zeroinitializer
1871   %0 = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %lane, <4 x float> %b, <4 x float> %a)
1872   ret <4 x float> %0
1873 }
1874
1875 define <2 x float> @test_vfms_lane_f32_0(<2 x float> %a, <2 x float> %b, <2 x float> %v) {
1876 ; CHECK: test_vfms_lane_f32_0:
1877 ; CHECK: fmls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
1878 ; CHECK-NEXT: ret
1879 entry:
1880   %sub = fsub <2 x float> <float -0.000000e+00, float -0.000000e+00>, %v
1881   %lane = shufflevector <2 x float> %sub, <2 x float> undef, <2 x i32> zeroinitializer
1882   %0 = tail call <2 x float> @llvm.fma.v2f32(<2 x float> %lane, <2 x float> %b, <2 x float> %a)
1883   ret <2 x float> %0
1884 }
1885
1886 define <4 x float> @test_vfmsq_lane_f32_0(<4 x float> %a, <4 x float> %b, <2 x float> %v) {
1887 ; CHECK: test_vfmsq_lane_f32_0:
1888 ; CHECK: fmls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
1889 ; CHECK-NEXT: ret
1890 entry:
1891   %sub = fsub <2 x float> <float -0.000000e+00, float -0.000000e+00>, %v
1892   %lane = shufflevector <2 x float> %sub, <2 x float> undef, <4 x i32> zeroinitializer
1893   %0 = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %lane, <4 x float> %b, <4 x float> %a)
1894   ret <4 x float> %0
1895 }
1896
1897 define <2 x float> @test_vfms_laneq_f32_0(<2 x float> %a, <2 x float> %b, <4 x float> %v) {
1898 ; CHECK: test_vfms_laneq_f32_0:
1899 ; CHECK: fmls {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
1900 ; CHECK-NEXT: ret
1901 entry:
1902   %sub = fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %v
1903   %lane = shufflevector <4 x float> %sub, <4 x float> undef, <2 x i32> zeroinitializer
1904   %0 = tail call <2 x float> @llvm.fma.v2f32(<2 x float> %lane, <2 x float> %b, <2 x float> %a)
1905   ret <2 x float> %0
1906 }
1907
1908 define <4 x float> @test_vfmsq_laneq_f32_0(<4 x float> %a, <4 x float> %b, <4 x float> %v) {
1909 ; CHECK: test_vfmsq_laneq_f32_0:
1910 ; CHECK: fmls {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
1911 ; CHECK-NEXT: ret
1912 entry:
1913   %sub = fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, %v
1914   %lane = shufflevector <4 x float> %sub, <4 x float> undef, <4 x i32> zeroinitializer
1915   %0 = tail call <4 x float> @llvm.fma.v4f32(<4 x float> %lane, <4 x float> %b, <4 x float> %a)
1916   ret <4 x float> %0
1917 }
1918
1919 define <2 x double> @test_vfmaq_laneq_f64_0(<2 x double> %a, <2 x double> %b, <2 x double> %v) {
1920 ; CHECK: test_vfmaq_laneq_f64_0:
1921 ; CHECK: fmla {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
1922 ; CHECK-NEXT: ret
1923 entry:
1924   %lane = shufflevector <2 x double> %v, <2 x double> undef, <2 x i32> zeroinitializer
1925   %0 = tail call <2 x double> @llvm.fma.v2f64(<2 x double> %lane, <2 x double> %b, <2 x double> %a)
1926   ret <2 x double> %0
1927 }
1928
1929 define <2 x double> @test_vfmsq_laneq_f64_0(<2 x double> %a, <2 x double> %b, <2 x double> %v) {
1930 ; CHECK: test_vfmsq_laneq_f64_0:
1931 ; CHECK: fmls {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
1932 ; CHECK-NEXT: ret
1933 entry:
1934   %sub = fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, %v
1935   %lane = shufflevector <2 x double> %sub, <2 x double> undef, <2 x i32> zeroinitializer
1936   %0 = tail call <2 x double> @llvm.fma.v2f64(<2 x double> %lane, <2 x double> %b, <2 x double> %a)
1937   ret <2 x double> %0
1938 }
1939
1940 define <4 x i32> @test_vmlal_lane_s16_0(<4 x i32> %a, <4 x i16> %b, <4 x i16> %v) {
1941 ; CHECK: test_vmlal_lane_s16_0:
1942 ; CHECK: mlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
1943 ; CHECK-NEXT: ret
1944 entry:
1945   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
1946   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
1947   %add = add <4 x i32> %vmull2.i, %a
1948   ret <4 x i32> %add
1949 }
1950
1951 define <2 x i64> @test_vmlal_lane_s32_0(<2 x i64> %a, <2 x i32> %b, <2 x i32> %v) {
1952 ; CHECK: test_vmlal_lane_s32_0:
1953 ; CHECK: mlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
1954 ; CHECK-NEXT: ret
1955 entry:
1956   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
1957   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
1958   %add = add <2 x i64> %vmull2.i, %a
1959   ret <2 x i64> %add
1960 }
1961
1962 define <4 x i32> @test_vmlal_laneq_s16_0(<4 x i32> %a, <4 x i16> %b, <8 x i16> %v) {
1963 ; CHECK: test_vmlal_laneq_s16_0:
1964 ; CHECK: mlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
1965 ; CHECK-NEXT: ret
1966 entry:
1967   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
1968   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
1969   %add = add <4 x i32> %vmull2.i, %a
1970   ret <4 x i32> %add
1971 }
1972
1973 define <2 x i64> @test_vmlal_laneq_s32_0(<2 x i64> %a, <2 x i32> %b, <4 x i32> %v) {
1974 ; CHECK: test_vmlal_laneq_s32_0:
1975 ; CHECK: mlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
1976 ; CHECK-NEXT: ret
1977 entry:
1978   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
1979   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
1980   %add = add <2 x i64> %vmull2.i, %a
1981   ret <2 x i64> %add
1982 }
1983
1984 define <4 x i32> @test_vmlal_high_lane_s16_0(<4 x i32> %a, <8 x i16> %b, <4 x i16> %v) {
1985 ; CHECK: test_vmlal_high_lane_s16_0:
1986 ; CHECK: mlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
1987 ; CHECK-NEXT: ret
1988 entry:
1989   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
1990   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
1991   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
1992   %add = add <4 x i32> %vmull2.i, %a
1993   ret <4 x i32> %add
1994 }
1995
1996 define <2 x i64> @test_vmlal_high_lane_s32_0(<2 x i64> %a, <4 x i32> %b, <2 x i32> %v) {
1997 ; CHECK: test_vmlal_high_lane_s32_0:
1998 ; CHECK: mlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
1999 ; CHECK-NEXT: ret
2000 entry:
2001   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2002   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2003   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2004   %add = add <2 x i64> %vmull2.i, %a
2005   ret <2 x i64> %add
2006 }
2007
2008 define <4 x i32> @test_vmlal_high_laneq_s16_0(<4 x i32> %a, <8 x i16> %b, <8 x i16> %v) {
2009 ; CHECK: test_vmlal_high_laneq_s16_0:
2010 ; CHECK: mlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2011 ; CHECK-NEXT: ret
2012 entry:
2013   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2014   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
2015   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2016   %add = add <4 x i32> %vmull2.i, %a
2017   ret <4 x i32> %add
2018 }
2019
2020 define <2 x i64> @test_vmlal_high_laneq_s32_0(<2 x i64> %a, <4 x i32> %b, <4 x i32> %v) {
2021 ; CHECK: test_vmlal_high_laneq_s32_0:
2022 ; CHECK: mlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2023 ; CHECK-NEXT: ret
2024 entry:
2025   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2026   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
2027   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2028   %add = add <2 x i64> %vmull2.i, %a
2029   ret <2 x i64> %add
2030 }
2031
2032 define <4 x i32> @test_vmlsl_lane_s16_0(<4 x i32> %a, <4 x i16> %b, <4 x i16> %v) {
2033 ; CHECK: test_vmlsl_lane_s16_0:
2034 ; CHECK: mlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2035 ; CHECK-NEXT: ret
2036 entry:
2037   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2038   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
2039   %sub = sub <4 x i32> %a, %vmull2.i
2040   ret <4 x i32> %sub
2041 }
2042
2043 define <2 x i64> @test_vmlsl_lane_s32_0(<2 x i64> %a, <2 x i32> %b, <2 x i32> %v) {
2044 ; CHECK: test_vmlsl_lane_s32_0:
2045 ; CHECK: mlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2046 ; CHECK-NEXT: ret
2047 entry:
2048   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2049   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
2050   %sub = sub <2 x i64> %a, %vmull2.i
2051   ret <2 x i64> %sub
2052 }
2053
2054 define <4 x i32> @test_vmlsl_laneq_s16_0(<4 x i32> %a, <4 x i16> %b, <8 x i16> %v) {
2055 ; CHECK: test_vmlsl_laneq_s16_0:
2056 ; CHECK: mlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2057 ; CHECK-NEXT: ret
2058 entry:
2059   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
2060   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
2061   %sub = sub <4 x i32> %a, %vmull2.i
2062   ret <4 x i32> %sub
2063 }
2064
2065 define <2 x i64> @test_vmlsl_laneq_s32_0(<2 x i64> %a, <2 x i32> %b, <4 x i32> %v) {
2066 ; CHECK: test_vmlsl_laneq_s32_0:
2067 ; CHECK: mlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2068 ; CHECK-NEXT: ret
2069 entry:
2070   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
2071   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
2072   %sub = sub <2 x i64> %a, %vmull2.i
2073   ret <2 x i64> %sub
2074 }
2075
2076 define <4 x i32> @test_vmlsl_high_lane_s16_0(<4 x i32> %a, <8 x i16> %b, <4 x i16> %v) {
2077 ; CHECK: test_vmlsl_high_lane_s16_0:
2078 ; CHECK: mlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2079 ; CHECK-NEXT: ret
2080 entry:
2081   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2082   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2083   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2084   %sub = sub <4 x i32> %a, %vmull2.i
2085   ret <4 x i32> %sub
2086 }
2087
2088 define <2 x i64> @test_vmlsl_high_lane_s32_0(<2 x i64> %a, <4 x i32> %b, <2 x i32> %v) {
2089 ; CHECK: test_vmlsl_high_lane_s32_0:
2090 ; CHECK: mlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2091 ; CHECK-NEXT: ret
2092 entry:
2093   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2094   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2095   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2096   %sub = sub <2 x i64> %a, %vmull2.i
2097   ret <2 x i64> %sub
2098 }
2099
2100 define <4 x i32> @test_vmlsl_high_laneq_s16_0(<4 x i32> %a, <8 x i16> %b, <8 x i16> %v) {
2101 ; CHECK: test_vmlsl_high_laneq_s16_0:
2102 ; CHECK: mlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2103 ; CHECK-NEXT: ret
2104 entry:
2105   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2106   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
2107   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2108   %sub = sub <4 x i32> %a, %vmull2.i
2109   ret <4 x i32> %sub
2110 }
2111
2112 define <2 x i64> @test_vmlsl_high_laneq_s32_0(<2 x i64> %a, <4 x i32> %b, <4 x i32> %v) {
2113 ; CHECK: test_vmlsl_high_laneq_s32_0:
2114 ; CHECK: mlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2115 ; CHECK-NEXT: ret
2116 entry:
2117   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2118   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
2119   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2120   %sub = sub <2 x i64> %a, %vmull2.i
2121   ret <2 x i64> %sub
2122 }
2123
2124 define <4 x i32> @test_vmlal_lane_u16_0(<4 x i32> %a, <4 x i16> %b, <4 x i16> %v) {
2125 ; CHECK: test_vmlal_lane_u16_0:
2126 ; CHECK: mlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2127 ; CHECK-NEXT: ret
2128 entry:
2129   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2130   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
2131   %add = add <4 x i32> %vmull2.i, %a
2132   ret <4 x i32> %add
2133 }
2134
2135 define <2 x i64> @test_vmlal_lane_u32_0(<2 x i64> %a, <2 x i32> %b, <2 x i32> %v) {
2136 ; CHECK: test_vmlal_lane_u32_0:
2137 ; CHECK: mlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2138 ; CHECK-NEXT: ret
2139 entry:
2140   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2141   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
2142   %add = add <2 x i64> %vmull2.i, %a
2143   ret <2 x i64> %add
2144 }
2145
2146 define <4 x i32> @test_vmlal_laneq_u16_0(<4 x i32> %a, <4 x i16> %b, <8 x i16> %v) {
2147 ; CHECK: test_vmlal_laneq_u16_0:
2148 ; CHECK: mlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2149 ; CHECK-NEXT: ret
2150 entry:
2151   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
2152   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
2153   %add = add <4 x i32> %vmull2.i, %a
2154   ret <4 x i32> %add
2155 }
2156
2157 define <2 x i64> @test_vmlal_laneq_u32_0(<2 x i64> %a, <2 x i32> %b, <4 x i32> %v) {
2158 ; CHECK: test_vmlal_laneq_u32_0:
2159 ; CHECK: mlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2160 ; CHECK-NEXT: ret
2161 entry:
2162   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
2163   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
2164   %add = add <2 x i64> %vmull2.i, %a
2165   ret <2 x i64> %add
2166 }
2167
2168 define <4 x i32> @test_vmlal_high_lane_u16_0(<4 x i32> %a, <8 x i16> %b, <4 x i16> %v) {
2169 ; CHECK: test_vmlal_high_lane_u16_0:
2170 ; CHECK: mlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2171 ; CHECK-NEXT: ret
2172 entry:
2173   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2174   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2175   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2176   %add = add <4 x i32> %vmull2.i, %a
2177   ret <4 x i32> %add
2178 }
2179
2180 define <2 x i64> @test_vmlal_high_lane_u32_0(<2 x i64> %a, <4 x i32> %b, <2 x i32> %v) {
2181 ; CHECK: test_vmlal_high_lane_u32_0:
2182 ; CHECK: mlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2183 ; CHECK-NEXT: ret
2184 entry:
2185   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2186   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2187   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2188   %add = add <2 x i64> %vmull2.i, %a
2189   ret <2 x i64> %add
2190 }
2191
2192 define <4 x i32> @test_vmlal_high_laneq_u16_0(<4 x i32> %a, <8 x i16> %b, <8 x i16> %v) {
2193 ; CHECK: test_vmlal_high_laneq_u16_0:
2194 ; CHECK: mlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2195 ; CHECK-NEXT: ret
2196 entry:
2197   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2198   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
2199   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2200   %add = add <4 x i32> %vmull2.i, %a
2201   ret <4 x i32> %add
2202 }
2203
2204 define <2 x i64> @test_vmlal_high_laneq_u32_0(<2 x i64> %a, <4 x i32> %b, <4 x i32> %v) {
2205 ; CHECK: test_vmlal_high_laneq_u32_0:
2206 ; CHECK: mlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2207 ; CHECK-NEXT: ret
2208 entry:
2209   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2210   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
2211   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2212   %add = add <2 x i64> %vmull2.i, %a
2213   ret <2 x i64> %add
2214 }
2215
2216 define <4 x i32> @test_vmlsl_lane_u16_0(<4 x i32> %a, <4 x i16> %b, <4 x i16> %v) {
2217 ; CHECK: test_vmlsl_lane_u16_0:
2218 ; CHECK: mlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2219 ; CHECK-NEXT: ret
2220 entry:
2221   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2222   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
2223   %sub = sub <4 x i32> %a, %vmull2.i
2224   ret <4 x i32> %sub
2225 }
2226
2227 define <2 x i64> @test_vmlsl_lane_u32_0(<2 x i64> %a, <2 x i32> %b, <2 x i32> %v) {
2228 ; CHECK: test_vmlsl_lane_u32_0:
2229 ; CHECK: mlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2230 ; CHECK-NEXT: ret
2231 entry:
2232   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2233   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
2234   %sub = sub <2 x i64> %a, %vmull2.i
2235   ret <2 x i64> %sub
2236 }
2237
2238 define <4 x i32> @test_vmlsl_laneq_u16_0(<4 x i32> %a, <4 x i16> %b, <8 x i16> %v) {
2239 ; CHECK: test_vmlsl_laneq_u16_0:
2240 ; CHECK: mlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2241 ; CHECK-NEXT: ret
2242 entry:
2243   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
2244   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
2245   %sub = sub <4 x i32> %a, %vmull2.i
2246   ret <4 x i32> %sub
2247 }
2248
2249 define <2 x i64> @test_vmlsl_laneq_u32_0(<2 x i64> %a, <2 x i32> %b, <4 x i32> %v) {
2250 ; CHECK: test_vmlsl_laneq_u32_0:
2251 ; CHECK: mlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2252 ; CHECK-NEXT: ret
2253 entry:
2254   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
2255   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
2256   %sub = sub <2 x i64> %a, %vmull2.i
2257   ret <2 x i64> %sub
2258 }
2259
2260 define <4 x i32> @test_vmlsl_high_lane_u16_0(<4 x i32> %a, <8 x i16> %b, <4 x i16> %v) {
2261 ; CHECK: test_vmlsl_high_lane_u16_0:
2262 ; CHECK: mlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2263 ; CHECK-NEXT: ret
2264 entry:
2265   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2266   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2267   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2268   %sub = sub <4 x i32> %a, %vmull2.i
2269   ret <4 x i32> %sub
2270 }
2271
2272 define <2 x i64> @test_vmlsl_high_lane_u32_0(<2 x i64> %a, <4 x i32> %b, <2 x i32> %v) {
2273 ; CHECK: test_vmlsl_high_lane_u32_0:
2274 ; CHECK: mlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2275 ; CHECK-NEXT: ret
2276 entry:
2277   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2278   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2279   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2280   %sub = sub <2 x i64> %a, %vmull2.i
2281   ret <2 x i64> %sub
2282 }
2283
2284 define <4 x i32> @test_vmlsl_high_laneq_u16_0(<4 x i32> %a, <8 x i16> %b, <8 x i16> %v) {
2285 ; CHECK: test_vmlsl_high_laneq_u16_0:
2286 ; CHECK: mlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2287 ; CHECK-NEXT: ret
2288 entry:
2289   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2290   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
2291   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2292   %sub = sub <4 x i32> %a, %vmull2.i
2293   ret <4 x i32> %sub
2294 }
2295
2296 define <2 x i64> @test_vmlsl_high_laneq_u32_0(<2 x i64> %a, <4 x i32> %b, <4 x i32> %v) {
2297 ; CHECK: test_vmlsl_high_laneq_u32_0:
2298 ; CHECK: mlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2299 ; CHECK-NEXT: ret
2300 entry:
2301   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2302   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
2303   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2304   %sub = sub <2 x i64> %a, %vmull2.i
2305   ret <2 x i64> %sub
2306 }
2307
2308 define <4 x i32> @test_vmull_lane_s16_0(<4 x i16> %a, <4 x i16> %v) {
2309 ; CHECK: test_vmull_lane_s16_0:
2310 ; CHECK: mull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2311 ; CHECK-NEXT: ret
2312 entry:
2313   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2314   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %a, <4 x i16> %shuffle)
2315   ret <4 x i32> %vmull2.i
2316 }
2317
2318 define <2 x i64> @test_vmull_lane_s32_0(<2 x i32> %a, <2 x i32> %v) {
2319 ; CHECK: test_vmull_lane_s32_0:
2320 ; CHECK: mull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2321 ; CHECK-NEXT: ret
2322 entry:
2323   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2324   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %a, <2 x i32> %shuffle)
2325   ret <2 x i64> %vmull2.i
2326 }
2327
2328 define <4 x i32> @test_vmull_lane_u16_0(<4 x i16> %a, <4 x i16> %v) {
2329 ; CHECK: test_vmull_lane_u16_0:
2330 ; CHECK: mull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2331 ; CHECK-NEXT: ret
2332 entry:
2333   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2334   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %a, <4 x i16> %shuffle)
2335   ret <4 x i32> %vmull2.i
2336 }
2337
2338 define <2 x i64> @test_vmull_lane_u32_0(<2 x i32> %a, <2 x i32> %v) {
2339 ; CHECK: test_vmull_lane_u32_0:
2340 ; CHECK: mull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2341 ; CHECK-NEXT: ret
2342 entry:
2343   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2344   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %a, <2 x i32> %shuffle)
2345   ret <2 x i64> %vmull2.i
2346 }
2347
2348 define <4 x i32> @test_vmull_high_lane_s16_0(<8 x i16> %a, <4 x i16> %v) {
2349 ; CHECK: test_vmull_high_lane_s16_0:
2350 ; CHECK: mull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2351 ; CHECK-NEXT: ret
2352 entry:
2353   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2354   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2355   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2356   ret <4 x i32> %vmull2.i
2357 }
2358
2359 define <2 x i64> @test_vmull_high_lane_s32_0(<4 x i32> %a, <2 x i32> %v) {
2360 ; CHECK: test_vmull_high_lane_s32_0:
2361 ; CHECK: mull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2362 ; CHECK-NEXT: ret
2363 entry:
2364   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2365   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2366   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2367   ret <2 x i64> %vmull2.i
2368 }
2369
2370 define <4 x i32> @test_vmull_high_lane_u16_0(<8 x i16> %a, <4 x i16> %v) {
2371 ; CHECK: test_vmull_high_lane_u16_0:
2372 ; CHECK: mull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2373 ; CHECK-NEXT: ret
2374 entry:
2375   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2376   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2377   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2378   ret <4 x i32> %vmull2.i
2379 }
2380
2381 define <2 x i64> @test_vmull_high_lane_u32_0(<4 x i32> %a, <2 x i32> %v) {
2382 ; CHECK: test_vmull_high_lane_u32_0:
2383 ; CHECK: mull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2384 ; CHECK-NEXT: ret
2385 entry:
2386   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2387   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2388   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2389   ret <2 x i64> %vmull2.i
2390 }
2391
2392 define <4 x i32> @test_vmull_laneq_s16_0(<4 x i16> %a, <8 x i16> %v) {
2393 ; CHECK: test_vmull_laneq_s16_0:
2394 ; CHECK: mull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2395 ; CHECK-NEXT: ret
2396 entry:
2397   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
2398   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %a, <4 x i16> %shuffle)
2399   ret <4 x i32> %vmull2.i
2400 }
2401
2402 define <2 x i64> @test_vmull_laneq_s32_0(<2 x i32> %a, <4 x i32> %v) {
2403 ; CHECK: test_vmull_laneq_s32_0:
2404 ; CHECK: mull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2405 ; CHECK-NEXT: ret
2406 entry:
2407   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
2408   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %a, <2 x i32> %shuffle)
2409   ret <2 x i64> %vmull2.i
2410 }
2411
2412 define <4 x i32> @test_vmull_laneq_u16_0(<4 x i16> %a, <8 x i16> %v) {
2413 ; CHECK: test_vmull_laneq_u16_0:
2414 ; CHECK: mull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2415 ; CHECK-NEXT: ret
2416 entry:
2417   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
2418   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %a, <4 x i16> %shuffle)
2419   ret <4 x i32> %vmull2.i
2420 }
2421
2422 define <2 x i64> @test_vmull_laneq_u32_0(<2 x i32> %a, <4 x i32> %v) {
2423 ; CHECK: test_vmull_laneq_u32_0:
2424 ; CHECK: mull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2425 ; CHECK-NEXT: ret
2426 entry:
2427   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
2428   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %a, <2 x i32> %shuffle)
2429   ret <2 x i64> %vmull2.i
2430 }
2431
2432 define <4 x i32> @test_vmull_high_laneq_s16_0(<8 x i16> %a, <8 x i16> %v) {
2433 ; CHECK: test_vmull_high_laneq_s16_0:
2434 ; CHECK: mull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2435 ; CHECK-NEXT: ret
2436 entry:
2437   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2438   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
2439   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmulls.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2440   ret <4 x i32> %vmull2.i
2441 }
2442
2443 define <2 x i64> @test_vmull_high_laneq_s32_0(<4 x i32> %a, <4 x i32> %v) {
2444 ; CHECK: test_vmull_high_laneq_s32_0:
2445 ; CHECK: mull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2446 ; CHECK-NEXT: ret
2447 entry:
2448   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2449   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
2450   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmulls.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2451   ret <2 x i64> %vmull2.i
2452 }
2453
2454 define <4 x i32> @test_vmull_high_laneq_u16_0(<8 x i16> %a, <8 x i16> %v) {
2455 ; CHECK: test_vmull_high_laneq_u16_0:
2456 ; CHECK: mull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2457 ; CHECK-NEXT: ret
2458 entry:
2459   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2460   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
2461   %vmull2.i = tail call <4 x i32> @llvm.arm.neon.vmullu.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2462   ret <4 x i32> %vmull2.i
2463 }
2464
2465 define <2 x i64> @test_vmull_high_laneq_u32_0(<4 x i32> %a, <4 x i32> %v) {
2466 ; CHECK: test_vmull_high_laneq_u32_0:
2467 ; CHECK: mull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2468 ; CHECK-NEXT: ret
2469 entry:
2470   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2471   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
2472   %vmull2.i = tail call <2 x i64> @llvm.arm.neon.vmullu.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2473   ret <2 x i64> %vmull2.i
2474 }
2475
2476 define <4 x i32> @test_vqdmlal_lane_s16_0(<4 x i32> %a, <4 x i16> %b, <4 x i16> %v) {
2477 ; CHECK: test_vqdmlal_lane_s16_0:
2478 ; CHECK: qdmlal {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2479 ; CHECK-NEXT: ret
2480 entry:
2481   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2482   %vqdmlal2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
2483   %vqdmlal4.i = tail call <4 x i32> @llvm.arm.neon.vqadds.v4i32(<4 x i32> %a, <4 x i32> %vqdmlal2.i)
2484   ret <4 x i32> %vqdmlal4.i
2485 }
2486
2487 define <2 x i64> @test_vqdmlal_lane_s32_0(<2 x i64> %a, <2 x i32> %b, <2 x i32> %v) {
2488 ; CHECK: test_vqdmlal_lane_s32_0:
2489 ; CHECK: qdmlal {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2490 ; CHECK-NEXT: ret
2491 entry:
2492   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2493   %vqdmlal2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
2494   %vqdmlal4.i = tail call <2 x i64> @llvm.arm.neon.vqadds.v2i64(<2 x i64> %a, <2 x i64> %vqdmlal2.i)
2495   ret <2 x i64> %vqdmlal4.i
2496 }
2497
2498 define <4 x i32> @test_vqdmlal_high_lane_s16_0(<4 x i32> %a, <8 x i16> %b, <4 x i16> %v) {
2499 ; CHECK: test_vqdmlal_high_lane_s16_0:
2500 ; CHECK: qdmlal2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2501 ; CHECK-NEXT: ret
2502 entry:
2503   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2504   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2505   %vqdmlal2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2506   %vqdmlal4.i = tail call <4 x i32> @llvm.arm.neon.vqadds.v4i32(<4 x i32> %a, <4 x i32> %vqdmlal2.i)
2507   ret <4 x i32> %vqdmlal4.i
2508 }
2509
2510 define <2 x i64> @test_vqdmlal_high_lane_s32_0(<2 x i64> %a, <4 x i32> %b, <2 x i32> %v) {
2511 ; CHECK: test_vqdmlal_high_lane_s32_0:
2512 ; CHECK: qdmlal2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2513 ; CHECK-NEXT: ret
2514 entry:
2515   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2516   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2517   %vqdmlal2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2518   %vqdmlal4.i = tail call <2 x i64> @llvm.arm.neon.vqadds.v2i64(<2 x i64> %a, <2 x i64> %vqdmlal2.i)
2519   ret <2 x i64> %vqdmlal4.i
2520 }
2521
2522 define <4 x i32> @test_vqdmlsl_lane_s16_0(<4 x i32> %a, <4 x i16> %b, <4 x i16> %v) {
2523 ; CHECK: test_vqdmlsl_lane_s16_0:
2524 ; CHECK: qdmlsl {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2525 ; CHECK-NEXT: ret
2526 entry:
2527   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2528   %vqdmlsl2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %b, <4 x i16> %shuffle)
2529   %vqdmlsl4.i = tail call <4 x i32> @llvm.arm.neon.vqsubs.v4i32(<4 x i32> %a, <4 x i32> %vqdmlsl2.i)
2530   ret <4 x i32> %vqdmlsl4.i
2531 }
2532
2533 define <2 x i64> @test_vqdmlsl_lane_s32_0(<2 x i64> %a, <2 x i32> %b, <2 x i32> %v) {
2534 ; CHECK: test_vqdmlsl_lane_s32_0:
2535 ; CHECK: qdmlsl {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2536 ; CHECK-NEXT: ret
2537 entry:
2538   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2539   %vqdmlsl2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %b, <2 x i32> %shuffle)
2540   %vqdmlsl4.i = tail call <2 x i64> @llvm.arm.neon.vqsubs.v2i64(<2 x i64> %a, <2 x i64> %vqdmlsl2.i)
2541   ret <2 x i64> %vqdmlsl4.i
2542 }
2543
2544 define <4 x i32> @test_vqdmlsl_high_lane_s16_0(<4 x i32> %a, <8 x i16> %b, <4 x i16> %v) {
2545 ; CHECK: test_vqdmlsl_high_lane_s16_0:
2546 ; CHECK: qdmlsl2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2547 ; CHECK-NEXT: ret
2548 entry:
2549   %shuffle.i = shufflevector <8 x i16> %b, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2550   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2551   %vqdmlsl2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2552   %vqdmlsl4.i = tail call <4 x i32> @llvm.arm.neon.vqsubs.v4i32(<4 x i32> %a, <4 x i32> %vqdmlsl2.i)
2553   ret <4 x i32> %vqdmlsl4.i
2554 }
2555
2556 define <2 x i64> @test_vqdmlsl_high_lane_s32_0(<2 x i64> %a, <4 x i32> %b, <2 x i32> %v) {
2557 ; CHECK: test_vqdmlsl_high_lane_s32_0:
2558 ; CHECK: qdmlsl2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2559 ; CHECK-NEXT: ret
2560 entry:
2561   %shuffle.i = shufflevector <4 x i32> %b, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2562   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2563   %vqdmlsl2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2564   %vqdmlsl4.i = tail call <2 x i64> @llvm.arm.neon.vqsubs.v2i64(<2 x i64> %a, <2 x i64> %vqdmlsl2.i)
2565   ret <2 x i64> %vqdmlsl4.i
2566 }
2567
2568 define <4 x i32> @test_vqdmull_lane_s16_0(<4 x i16> %a, <4 x i16> %v) {
2569 ; CHECK: test_vqdmull_lane_s16_0:
2570 ; CHECK: qdmull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2571 ; CHECK-NEXT: ret
2572 entry:
2573   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2574   %vqdmull2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %a, <4 x i16> %shuffle)
2575   ret <4 x i32> %vqdmull2.i
2576 }
2577
2578 define <2 x i64> @test_vqdmull_lane_s32_0(<2 x i32> %a, <2 x i32> %v) {
2579 ; CHECK: test_vqdmull_lane_s32_0:
2580 ; CHECK: qdmull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2581 ; CHECK-NEXT: ret
2582 entry:
2583   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2584   %vqdmull2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %a, <2 x i32> %shuffle)
2585   ret <2 x i64> %vqdmull2.i
2586 }
2587
2588 define <4 x i32> @test_vqdmull_laneq_s16_0(<4 x i16> %a, <8 x i16> %v) {
2589 ; CHECK: test_vqdmull_laneq_s16_0:
2590 ; CHECK: qdmull {{v[0-9]+}}.4s, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2591 ; CHECK-NEXT: ret
2592 entry:
2593   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
2594   %vqdmull2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %a, <4 x i16> %shuffle)
2595   ret <4 x i32> %vqdmull2.i
2596 }
2597
2598 define <2 x i64> @test_vqdmull_laneq_s32_0(<2 x i32> %a, <4 x i32> %v) {
2599 ; CHECK: test_vqdmull_laneq_s32_0:
2600 ; CHECK: qdmull {{v[0-9]+}}.2d, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2601 ; CHECK-NEXT: ret
2602 entry:
2603   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
2604   %vqdmull2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %a, <2 x i32> %shuffle)
2605   ret <2 x i64> %vqdmull2.i
2606 }
2607
2608 define <4 x i32> @test_vqdmull_high_lane_s16_0(<8 x i16> %a, <4 x i16> %v) {
2609 ; CHECK: test_vqdmull_high_lane_s16_0:
2610 ; CHECK: qdmull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2611 ; CHECK-NEXT: ret
2612 entry:
2613   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2614   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2615   %vqdmull2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2616   ret <4 x i32> %vqdmull2.i
2617 }
2618
2619 define <2 x i64> @test_vqdmull_high_lane_s32_0(<4 x i32> %a, <2 x i32> %v) {
2620 ; CHECK: test_vqdmull_high_lane_s32_0:
2621 ; CHECK: qdmull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2622 ; CHECK-NEXT: ret
2623 entry:
2624   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2625   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2626   %vqdmull2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2627   ret <2 x i64> %vqdmull2.i
2628 }
2629
2630 define <4 x i32> @test_vqdmull_high_laneq_s16_0(<8 x i16> %a, <8 x i16> %v) {
2631 ; CHECK: test_vqdmull_high_laneq_s16_0:
2632 ; CHECK: qdmull2 {{v[0-9]+}}.4s, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2633 ; CHECK-NEXT: ret
2634 entry:
2635   %shuffle.i = shufflevector <8 x i16> %a, <8 x i16> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>
2636   %shuffle = shufflevector <8 x i16> %v, <8 x i16> undef, <4 x i32> zeroinitializer
2637   %vqdmull2.i = tail call <4 x i32> @llvm.arm.neon.vqdmull.v4i32(<4 x i16> %shuffle.i, <4 x i16> %shuffle)
2638   ret <4 x i32> %vqdmull2.i
2639 }
2640
2641 define <2 x i64> @test_vqdmull_high_laneq_s32_0(<4 x i32> %a, <4 x i32> %v) {
2642 ; CHECK: test_vqdmull_high_laneq_s32_0:
2643 ; CHECK: qdmull2 {{v[0-9]+}}.2d, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2644 ; CHECK-NEXT: ret
2645 entry:
2646   %shuffle.i = shufflevector <4 x i32> %a, <4 x i32> undef, <2 x i32> <i32 2, i32 3>
2647   %shuffle = shufflevector <4 x i32> %v, <4 x i32> undef, <2 x i32> zeroinitializer
2648   %vqdmull2.i = tail call <2 x i64> @llvm.arm.neon.vqdmull.v2i64(<2 x i32> %shuffle.i, <2 x i32> %shuffle)
2649   ret <2 x i64> %vqdmull2.i
2650 }
2651
2652 define <4 x i16> @test_vqdmulh_lane_s16_0(<4 x i16> %a, <4 x i16> %v) {
2653 ; CHECK: test_vqdmulh_lane_s16_0:
2654 ; CHECK: qdmulh {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2655 ; CHECK-NEXT: ret
2656 entry:
2657   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2658   %vqdmulh2.i = tail call <4 x i16> @llvm.arm.neon.vqdmulh.v4i16(<4 x i16> %a, <4 x i16> %shuffle)
2659   ret <4 x i16> %vqdmulh2.i
2660 }
2661
2662 define <8 x i16> @test_vqdmulhq_lane_s16_0(<8 x i16> %a, <4 x i16> %v) {
2663 ; CHECK: test_vqdmulhq_lane_s16_0:
2664 ; CHECK: qdmulh {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2665 ; CHECK-NEXT: ret
2666 entry:
2667   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <8 x i32> zeroinitializer
2668   %vqdmulh2.i = tail call <8 x i16> @llvm.arm.neon.vqdmulh.v8i16(<8 x i16> %a, <8 x i16> %shuffle)
2669   ret <8 x i16> %vqdmulh2.i
2670 }
2671
2672 define <2 x i32> @test_vqdmulh_lane_s32_0(<2 x i32> %a, <2 x i32> %v) {
2673 ; CHECK: test_vqdmulh_lane_s32_0:
2674 ; CHECK: qdmulh {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2675 ; CHECK-NEXT: ret
2676 entry:
2677   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2678   %vqdmulh2.i = tail call <2 x i32> @llvm.arm.neon.vqdmulh.v2i32(<2 x i32> %a, <2 x i32> %shuffle)
2679   ret <2 x i32> %vqdmulh2.i
2680 }
2681
2682 define <4 x i32> @test_vqdmulhq_lane_s32_0(<4 x i32> %a, <2 x i32> %v) {
2683 ; CHECK: test_vqdmulhq_lane_s32_0:
2684 ; CHECK: qdmulh {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2685 ; CHECK-NEXT: ret
2686 entry:
2687   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <4 x i32> zeroinitializer
2688   %vqdmulh2.i = tail call <4 x i32> @llvm.arm.neon.vqdmulh.v4i32(<4 x i32> %a, <4 x i32> %shuffle)
2689   ret <4 x i32> %vqdmulh2.i
2690 }
2691
2692 define <4 x i16> @test_vqrdmulh_lane_s16_0(<4 x i16> %a, <4 x i16> %v) {
2693 ; CHECK: test_vqrdmulh_lane_s16_0:
2694 ; CHECK: qrdmulh {{v[0-9]+}}.4h, {{v[0-9]+}}.4h, {{v[0-9]+}}.h[0]
2695 ; CHECK-NEXT: ret
2696 entry:
2697   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <4 x i32> zeroinitializer
2698   %vqrdmulh2.i = tail call <4 x i16> @llvm.arm.neon.vqrdmulh.v4i16(<4 x i16> %a, <4 x i16> %shuffle)
2699   ret <4 x i16> %vqrdmulh2.i
2700 }
2701
2702 define <8 x i16> @test_vqrdmulhq_lane_s16_0(<8 x i16> %a, <4 x i16> %v) {
2703 ; CHECK: test_vqrdmulhq_lane_s16_0:
2704 ; CHECK: qrdmulh {{v[0-9]+}}.8h, {{v[0-9]+}}.8h, {{v[0-9]+}}.h[0]
2705 ; CHECK-NEXT: ret
2706 entry:
2707   %shuffle = shufflevector <4 x i16> %v, <4 x i16> undef, <8 x i32> zeroinitializer
2708   %vqrdmulh2.i = tail call <8 x i16> @llvm.arm.neon.vqrdmulh.v8i16(<8 x i16> %a, <8 x i16> %shuffle)
2709   ret <8 x i16> %vqrdmulh2.i
2710 }
2711
2712 define <2 x i32> @test_vqrdmulh_lane_s32_0(<2 x i32> %a, <2 x i32> %v) {
2713 ; CHECK: test_vqrdmulh_lane_s32_0:
2714 ; CHECK: qrdmulh {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2715 ; CHECK-NEXT: ret
2716 entry:
2717   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <2 x i32> zeroinitializer
2718   %vqrdmulh2.i = tail call <2 x i32> @llvm.arm.neon.vqrdmulh.v2i32(<2 x i32> %a, <2 x i32> %shuffle)
2719   ret <2 x i32> %vqrdmulh2.i
2720 }
2721
2722 define <4 x i32> @test_vqrdmulhq_lane_s32_0(<4 x i32> %a, <2 x i32> %v) {
2723 ; CHECK: test_vqrdmulhq_lane_s32_0:
2724 ; CHECK: qrdmulh {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2725 ; CHECK-NEXT: ret
2726 entry:
2727   %shuffle = shufflevector <2 x i32> %v, <2 x i32> undef, <4 x i32> zeroinitializer
2728   %vqrdmulh2.i = tail call <4 x i32> @llvm.arm.neon.vqrdmulh.v4i32(<4 x i32> %a, <4 x i32> %shuffle)
2729   ret <4 x i32> %vqrdmulh2.i
2730 }
2731
2732 define <2 x float> @test_vmul_lane_f32_0(<2 x float> %a, <2 x float> %v) {
2733 ; CHECK: test_vmul_lane_f32_0:
2734 ; CHECK: fmul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2735 ; CHECK-NEXT: ret
2736 entry:
2737   %shuffle = shufflevector <2 x float> %v, <2 x float> undef, <2 x i32> zeroinitializer
2738   %mul = fmul <2 x float> %shuffle, %a
2739   ret <2 x float> %mul
2740 }
2741
2742 define <4 x float> @test_vmulq_lane_f32_0(<4 x float> %a, <2 x float> %v) {
2743 ; CHECK: test_vmulq_lane_f32_0:
2744 ; CHECK: fmul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2745 ; CHECK-NEXT: ret
2746 entry:
2747   %shuffle = shufflevector <2 x float> %v, <2 x float> undef, <4 x i32> zeroinitializer
2748   %mul = fmul <4 x float> %shuffle, %a
2749   ret <4 x float> %mul
2750 }
2751
2752 define <2 x float> @test_vmul_laneq_f32_0(<2 x float> %a, <4 x float> %v) {
2753 ; CHECK: test_vmul_laneq_f32_0:
2754 ; CHECK: fmul {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2755 ; CHECK-NEXT: ret
2756 entry:
2757   %shuffle = shufflevector <4 x float> %v, <4 x float> undef, <2 x i32> zeroinitializer
2758   %mul = fmul <2 x float> %shuffle, %a
2759   ret <2 x float> %mul
2760 }
2761
2762 define <1 x double> @test_vmul_laneq_f64_0(<1 x double> %a, <2 x double> %v) {
2763 ; CHECK: test_vmul_laneq_f64_0:
2764 ; CHECK: fmul {{d[0-9]+}}, {{d[0-9]+}}, {{v[0-9]+}}.d[0]
2765 ; CHECK-NEXT: ret
2766 entry:
2767   %0 = bitcast <1 x double> %a to <8 x i8>
2768   %1 = bitcast <8 x i8> %0 to double
2769   %extract = extractelement <2 x double> %v, i32 0
2770   %2 = fmul double %1, %extract
2771   %3 = insertelement <1 x double> undef, double %2, i32 0
2772   ret <1 x double> %3
2773 }
2774
2775 define <4 x float> @test_vmulq_laneq_f32_0(<4 x float> %a, <4 x float> %v) {
2776 ; CHECK: test_vmulq_laneq_f32_0:
2777 ; CHECK: fmul {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2778 ; CHECK-NEXT: ret
2779 entry:
2780   %shuffle = shufflevector <4 x float> %v, <4 x float> undef, <4 x i32> zeroinitializer
2781   %mul = fmul <4 x float> %shuffle, %a
2782   ret <4 x float> %mul
2783 }
2784
2785 define <2 x double> @test_vmulq_laneq_f64_0(<2 x double> %a, <2 x double> %v) {
2786 ; CHECK: test_vmulq_laneq_f64_0:
2787 ; CHECK: fmul {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
2788 ; CHECK-NEXT: ret
2789 entry:
2790   %shuffle = shufflevector <2 x double> %v, <2 x double> undef, <2 x i32> zeroinitializer
2791   %mul = fmul <2 x double> %shuffle, %a
2792   ret <2 x double> %mul
2793 }
2794
2795 define <2 x float> @test_vmulx_lane_f32_0(<2 x float> %a, <2 x float> %v) {
2796 ; CHECK: test_vmulx_lane_f32_0:
2797 ; CHECK: mulx {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2798 ; CHECK-NEXT: ret
2799 entry:
2800   %shuffle = shufflevector <2 x float> %v, <2 x float> undef, <2 x i32> zeroinitializer
2801   %vmulx2.i = tail call <2 x float> @llvm.aarch64.neon.vmulx.v2f32(<2 x float> %a, <2 x float> %shuffle)
2802   ret <2 x float> %vmulx2.i
2803 }
2804
2805 define <4 x float> @test_vmulxq_lane_f32_0(<4 x float> %a, <2 x float> %v) {
2806 ; CHECK: test_vmulxq_lane_f32_0:
2807 ; CHECK: mulx {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2808 ; CHECK-NEXT: ret
2809 entry:
2810   %shuffle = shufflevector <2 x float> %v, <2 x float> undef, <4 x i32> zeroinitializer
2811   %vmulx2.i = tail call <4 x float> @llvm.aarch64.neon.vmulx.v4f32(<4 x float> %a, <4 x float> %shuffle)
2812   ret <4 x float> %vmulx2.i
2813 }
2814
2815 define <2 x double> @test_vmulxq_lane_f64_0(<2 x double> %a, <1 x double> %v) {
2816 ; CHECK: test_vmulxq_lane_f64_0:
2817 ; CHECK: mulx {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
2818 ; CHECK-NEXT: ret
2819 entry:
2820   %shuffle = shufflevector <1 x double> %v, <1 x double> undef, <2 x i32> zeroinitializer
2821   %vmulx2.i = tail call <2 x double> @llvm.aarch64.neon.vmulx.v2f64(<2 x double> %a, <2 x double> %shuffle)
2822   ret <2 x double> %vmulx2.i
2823 }
2824
2825 define <2 x float> @test_vmulx_laneq_f32_0(<2 x float> %a, <4 x float> %v) {
2826 ; CHECK: test_vmulx_laneq_f32_0:
2827 ; CHECK: mulx {{v[0-9]+}}.2s, {{v[0-9]+}}.2s, {{v[0-9]+}}.s[0]
2828 ; CHECK-NEXT: ret
2829 entry:
2830   %shuffle = shufflevector <4 x float> %v, <4 x float> undef, <2 x i32> zeroinitializer
2831   %vmulx2.i = tail call <2 x float> @llvm.aarch64.neon.vmulx.v2f32(<2 x float> %a, <2 x float> %shuffle)
2832   ret <2 x float> %vmulx2.i
2833 }
2834
2835 define <4 x float> @test_vmulxq_laneq_f32_0(<4 x float> %a, <4 x float> %v) {
2836 ; CHECK: test_vmulxq_laneq_f32_0:
2837 ; CHECK: mulx {{v[0-9]+}}.4s, {{v[0-9]+}}.4s, {{v[0-9]+}}.s[0]
2838 ; CHECK-NEXT: ret
2839 entry:
2840   %shuffle = shufflevector <4 x float> %v, <4 x float> undef, <4 x i32> zeroinitializer
2841   %vmulx2.i = tail call <4 x float> @llvm.aarch64.neon.vmulx.v4f32(<4 x float> %a, <4 x float> %shuffle)
2842   ret <4 x float> %vmulx2.i
2843 }
2844
2845 define <2 x double> @test_vmulxq_laneq_f64_0(<2 x double> %a, <2 x double> %v) {
2846 ; CHECK: test_vmulxq_laneq_f64_0:
2847 ; CHECK: mulx {{v[0-9]+}}.2d, {{v[0-9]+}}.2d, {{v[0-9]+}}.d[0]
2848 ; CHECK-NEXT: ret
2849 entry:
2850   %shuffle = shufflevector <2 x double> %v, <2 x double> undef, <2 x i32> zeroinitializer
2851   %vmulx2.i = tail call <2 x double> @llvm.aarch64.neon.vmulx.v2f64(<2 x double> %a, <2 x double> %shuffle)
2852   ret <2 x double> %vmulx2.i
2853 }
2854