test/CodeGen/Mips/msa/shuffle.ll

   1 ; RUN: llc -march=mips -mattr=+msa,+fp64 < %s | FileCheck %s
   2 ; RUN: llc -march=mipsel -mattr=+msa,+fp64 < %s | FileCheck %s
   3
   4 define void @vshf_v16i8_0(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
   5   ; CHECK: vshf_v16i8_0:
   6
   7   %1 = load <16 x i8>* %a
   8   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
   9   %2 = shufflevector <16 x i8> %1, <16 x i8> undef, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
  10   ; CHECK-DAG: addiu [[PTR_A:\$[0-9]+]], {{.*}}, %lo($
  11   ; CHECK-DAG: ld.b [[R3:\$w[0-9]+]], 0([[PTR_A]])
  12   ; CHECK-DAG: vshf.b [[R3]], [[R1]], [[R1]]
  13   store <16 x i8> %2, <16 x i8>* %c
  14   ; CHECK-DAG: st.b [[R3]], 0($4)
  15
  16   ret void
  17   ; CHECK: .size vshf_v16i8_0
  18 }
  19
  20 define void @vshf_v16i8_1(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
  21   ; CHECK: vshf_v16i8_1:
  22
  23   %1 = load <16 x i8>* %a
  24   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
  25   %2 = shufflevector <16 x i8> %1, <16 x i8> undef, <16 x i32> <i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1>
  26   ; CHECK-DAG: splati.b [[R3:\$w[0-9]+]], [[R1]][1]
  27   store <16 x i8> %2, <16 x i8>* %c
  28   ; CHECK-DAG: st.b [[R3]], 0($4)
  29
  30   ret void
  31   ; CHECK: .size vshf_v16i8_1
  32 }
  33
  34 define void @vshf_v16i8_2(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
  35   ; CHECK: vshf_v16i8_2:
  36
  37   %1 = load <16 x i8>* %a
  38   %2 = load <16 x i8>* %b
  39   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
  40   %3 = shufflevector <16 x i8> %1, <16 x i8> %2, <16 x i32> <i32 16, i32 17, i32 18, i32 19, i32 20, i32 21, i32 22, i32 23, i32 24, i32 25, i32 26, i32 27, i32 28, i32 29, i32 30, i32 16>
  41   ; CHECK-DAG: addiu [[PTR_A:\$[0-9]+]], {{.*}}, %lo($
  42   ; CHECK-DAG: ld.b [[R3:\$w[0-9]+]], 0([[PTR_A]])
  43   ; CHECK-DAG: vshf.b [[R3]], [[R2]], [[R2]]
  44   store <16 x i8> %3, <16 x i8>* %c
  45   ; CHECK-DAG: st.b [[R3]], 0($4)
  46
  47   ret void
  48   ; CHECK: .size vshf_v16i8_2
  49 }
  50
  51 define void @vshf_v16i8_3(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
  52   ; CHECK: vshf_v16i8_3:
  53
  54   %1 = load <16 x i8>* %a
  55   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
  56   %2 = load <16 x i8>* %b
  57   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
  58   %3 = shufflevector <16 x i8> %1, <16 x i8> %2, <16 x i32> <i32 17, i32 24, i32 25, i32 18, i32 19, i32 20, i32 28, i32 19, i32 1, i32 8, i32 9, i32 2, i32 3, i32 4, i32 12, i32 3>
  59   ; CHECK-DAG: addiu [[PTR_A:\$[0-9]+]], {{.*}}, %lo($
  60   ; CHECK-DAG: ld.b [[R3:\$w[0-9]+]], 0([[PTR_A]])
  61   ; The concatenation step of vshf is bitwise not vectorwise so we must reverse
  62   ; the operands to get the right answer.
  63   ; CHECK-DAG: vshf.b [[R3]], [[R2]], [[R1]]
  64   store <16 x i8> %3, <16 x i8>* %c
  65   ; CHECK-DAG: st.b [[R3]], 0($4)
  66
  67   ret void
  68   ; CHECK: .size vshf_v16i8_3
  69 }
  70
  71 define void @vshf_v16i8_4(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
  72   ; CHECK: vshf_v16i8_4:
  73
  74   %1 = load <16 x i8>* %a
  75   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
  76   %2 = shufflevector <16 x i8> %1, <16 x i8> %1, <16 x i32> <i32 1, i32 17, i32 1, i32 17, i32 1, i32 17, i32 1, i32 17, i32 1, i32 17, i32 1, i32 17, i32 1, i32 17, i32 1, i32 17>
  77   ; CHECK-DAG: splati.b [[R3:\$w[0-9]+]], [[R1]][1]
  78   store <16 x i8> %2, <16 x i8>* %c
  79   ; CHECK-DAG: st.b [[R3]], 0($4)
  80
  81   ret void
  82   ; CHECK: .size vshf_v16i8_4
  83 }
  84
  85 define void @vshf_v8i16_0(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
  86   ; CHECK: vshf_v8i16_0:
  87
  88   %1 = load <8 x i16>* %a
  89   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
  90   %2 = shufflevector <8 x i16> %1, <8 x i16> undef, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
  91   ; CHECK-DAG: addiu [[PTR_A:\$[0-9]+]], {{.*}}, %lo($
  92   ; CHECK-DAG: ld.h [[R3:\$w[0-9]+]], 0([[PTR_A]])
  93   ; CHECK-DAG: vshf.h [[R3]], [[R1]], [[R1]]
  94   store <8 x i16> %2, <8 x i16>* %c
  95   ; CHECK-DAG: st.h [[R3]], 0($4)
  96
  97   ret void
  98   ; CHECK: .size vshf_v8i16_0
  99 }
 100
 101 define void @vshf_v8i16_1(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 102   ; CHECK: vshf_v8i16_1:
 103
 104   %1 = load <8 x i16>* %a
 105   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 106   %2 = shufflevector <8 x i16> %1, <8 x i16> undef, <8 x i32> <i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1, i32 1>
 107   ; CHECK-DAG: splati.h [[R3:\$w[0-9]+]], [[R1]][1]
 108   store <8 x i16> %2, <8 x i16>* %c
 109   ; CHECK-DAG: st.h [[R3]], 0($4)
 110
 111   ret void
 112   ; CHECK: .size vshf_v8i16_1
 113 }
 114
 115 define void @vshf_v8i16_2(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 116   ; CHECK: vshf_v8i16_2:
 117
 118   %1 = load <8 x i16>* %a
 119   %2 = load <8 x i16>* %b
 120   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 121   %3 = shufflevector <8 x i16> %1, <8 x i16> %2, <8 x i32> <i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 8>
 122   ; CHECK-DAG: addiu [[PTR_A:\$[0-9]+]], {{.*}}, %lo($
 123   ; CHECK-DAG: ld.h [[R3:\$w[0-9]+]], 0([[PTR_A]])
 124   ; CHECK-DAG: vshf.h [[R3]], [[R2]], [[R2]]
 125   store <8 x i16> %3, <8 x i16>* %c
 126   ; CHECK-DAG: st.h [[R3]], 0($4)
 127
 128   ret void
 129   ; CHECK: .size vshf_v8i16_2
 130 }
 131
 132 define void @vshf_v8i16_3(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 133   ; CHECK: vshf_v8i16_3:
 134
 135   %1 = load <8 x i16>* %a
 136   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 137   %2 = load <8 x i16>* %b
 138   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 139   %3 = shufflevector <8 x i16> %1, <8 x i16> %2, <8 x i32> <i32 1, i32 8, i32 9, i32 2, i32 3, i32 4, i32 12, i32 3>
 140   ; CHECK-DAG: addiu [[PTR_A:\$[0-9]+]], {{.*}}, %lo($
 141   ; CHECK-DAG: ld.h [[R3:\$w[0-9]+]], 0([[PTR_A]])
 142   ; The concatenation step of vshf is bitwise not vectorwise so we must reverse
 143   ; the operands to get the right answer.
 144   ; CHECK-DAG: vshf.h [[R3]], [[R2]], [[R1]]
 145   store <8 x i16> %3, <8 x i16>* %c
 146   ; CHECK-DAG: st.h [[R3]], 0($4)
 147
 148   ret void
 149   ; CHECK: .size vshf_v8i16_3
 150 }
 151
 152 define void @vshf_v8i16_4(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 153   ; CHECK: vshf_v8i16_4:
 154
 155   %1 = load <8 x i16>* %a
 156   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 157   %2 = shufflevector <8 x i16> %1, <8 x i16> %1, <8 x i32> <i32 1, i32 9, i32 1, i32 9, i32 1, i32 9, i32 1, i32 9>
 158   ; CHECK-DAG: splati.h [[R3:\$w[0-9]+]], [[R1]][1]
 159   store <8 x i16> %2, <8 x i16>* %c
 160   ; CHECK-DAG: st.h [[R3]], 0($4)
 161
 162   ret void
 163   ; CHECK: .size vshf_v8i16_4
 164 }
 165
 166 ; Note: v4i32 only has one 4-element set so it's impossible to get a vshf.w
 167 ; instruction when using a single vector.
 168
 169 define void @vshf_v4i32_0(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 170   ; CHECK: vshf_v4i32_0:
 171
 172   %1 = load <4 x i32>* %a
 173   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 174   %2 = shufflevector <4 x i32> %1, <4 x i32> undef, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
 175   ; CHECK-DAG: shf.w [[R3:\$w[0-9]+]], [[R1]], 27
 176   store <4 x i32> %2, <4 x i32>* %c
 177   ; CHECK-DAG: st.w [[R3]], 0($4)
 178
 179   ret void
 180   ; CHECK: .size vshf_v4i32_0
 181 }
 182
 183 define void @vshf_v4i32_1(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 184   ; CHECK: vshf_v4i32_1:
 185
 186   %1 = load <4 x i32>* %a
 187   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 188   %2 = shufflevector <4 x i32> %1, <4 x i32> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
 189   ; CHECK-DAG: shf.w [[R3:\$w[0-9]+]], [[R1]], 85
 190   store <4 x i32> %2, <4 x i32>* %c
 191   ; CHECK-DAG: st.w [[R3]], 0($4)
 192
 193   ret void
 194   ; CHECK: .size vshf_v4i32_1
 195 }
 196
 197 define void @vshf_v4i32_2(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 198   ; CHECK: vshf_v4i32_2:
 199
 200   %1 = load <4 x i32>* %a
 201   %2 = load <4 x i32>* %b
 202   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 203   %3 = shufflevector <4 x i32> %1, <4 x i32> %2, <4 x i32> <i32 4, i32 5, i32 6, i32 4>
 204   ; CHECK-DAG: shf.w [[R3:\$w[0-9]+]], [[R2]], 36
 205   store <4 x i32> %3, <4 x i32>* %c
 206   ; CHECK-DAG: st.w [[R3]], 0($4)
 207
 208   ret void
 209   ; CHECK: .size vshf_v4i32_2
 210 }
 211
 212 define void @vshf_v4i32_3(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 213   ; CHECK: vshf_v4i32_3:
 214
 215   %1 = load <4 x i32>* %a
 216   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 217   %2 = load <4 x i32>* %b
 218   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 219   %3 = shufflevector <4 x i32> %1, <4 x i32> %2, <4 x i32> <i32 1, i32 5, i32 6, i32 4>
 220   ; CHECK-DAG: addiu [[PTR_A:\$[0-9]+]], {{.*}}, %lo($
 221   ; CHECK-DAG: ld.w [[R3:\$w[0-9]+]], 0([[PTR_A]])
 222   ; The concatenation step of vshf is bitwise not vectorwise so we must reverse
 223   ; the operands to get the right answer.
 224   ; CHECK-DAG: vshf.w [[R3]], [[R2]], [[R1]]
 225   store <4 x i32> %3, <4 x i32>* %c
 226   ; CHECK-DAG: st.w [[R3]], 0($4)
 227
 228   ret void
 229   ; CHECK: .size vshf_v4i32_3
 230 }
 231
 232 define void @vshf_v4i32_4(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 233   ; CHECK: vshf_v4i32_4:
 234
 235   %1 = load <4 x i32>* %a
 236   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 237   %2 = shufflevector <4 x i32> %1, <4 x i32> %1, <4 x i32> <i32 1, i32 5, i32 5, i32 1>
 238   ; CHECK-DAG: shf.w [[R3:\$w[0-9]+]], [[R1]], 85
 239   store <4 x i32> %2, <4 x i32>* %c
 240   ; CHECK-DAG: st.w [[R3]], 0($4)
 241
 242   ret void
 243   ; CHECK: .size vshf_v4i32_4
 244 }
 245
 246 define void @vshf_v2i64_0(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 247   ; CHECK: vshf_v2i64_0:
 248
 249   %1 = load <2 x i64>* %a
 250   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 251   %2 = shufflevector <2 x i64> %1, <2 x i64> undef, <2 x i32> <i32 1, i32 0>
 252   ; CHECK-DAG: addiu [[PTR_A:\$[0-9]+]], {{.*}}, %lo($
 253   ; CHECK-DAG: ld.d [[R3:\$w[0-9]+]], 0([[PTR_A]])
 254   ; CHECK-DAG: vshf.d [[R3]], [[R1]], [[R1]]
 255   store <2 x i64> %2, <2 x i64>* %c
 256   ; CHECK-DAG: st.d [[R3]], 0($4)
 257
 258   ret void
 259   ; CHECK: .size vshf_v2i64_0
 260 }
 261
 262 define void @vshf_v2i64_1(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 263   ; CHECK: vshf_v2i64_1:
 264
 265   %1 = load <2 x i64>* %a
 266   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 267   %2 = shufflevector <2 x i64> %1, <2 x i64> undef, <2 x i32> <i32 1, i32 1>
 268   ; CHECK-DAG: splati.d [[R3:\$w[0-9]+]], [[R1]][1]
 269   store <2 x i64> %2, <2 x i64>* %c
 270   ; CHECK-DAG: st.d [[R3]], 0($4)
 271
 272   ret void
 273   ; CHECK: .size vshf_v2i64_1
 274 }
 275
 276 define void @vshf_v2i64_2(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 277   ; CHECK: vshf_v2i64_2:
 278
 279   %1 = load <2 x i64>* %a
 280   %2 = load <2 x i64>* %b
 281   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 282   %3 = shufflevector <2 x i64> %1, <2 x i64> %2, <2 x i32> <i32 3, i32 2>
 283   ; CHECK-DAG: addiu [[PTR_A:\$[0-9]+]], {{.*}}, %lo($
 284   ; CHECK-DAG: ld.d [[R3:\$w[0-9]+]], 0([[PTR_A]])
 285   ; CHECK-DAG: vshf.d [[R3]], [[R2]], [[R2]]
 286   store <2 x i64> %3, <2 x i64>* %c
 287   ; CHECK-DAG: st.d [[R3]], 0($4)
 288
 289   ret void
 290   ; CHECK: .size vshf_v2i64_2
 291 }
 292
 293 define void @vshf_v2i64_3(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 294   ; CHECK: vshf_v2i64_3:
 295
 296   %1 = load <2 x i64>* %a
 297   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 298   %2 = load <2 x i64>* %b
 299   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 300   %3 = shufflevector <2 x i64> %1, <2 x i64> %2, <2 x i32> <i32 1, i32 2>
 301   ; CHECK-DAG: addiu [[PTR_A:\$[0-9]+]], {{.*}}, %lo($
 302   ; CHECK-DAG: ld.d [[R3:\$w[0-9]+]], 0([[PTR_A]])
 303   ; The concatenation step of vshf is bitwise not vectorwise so we must reverse
 304   ; the operands to get the right answer.
 305   ; CHECK-DAG: vshf.d [[R3]], [[R2]], [[R1]]
 306   store <2 x i64> %3, <2 x i64>* %c
 307   ; CHECK-DAG: st.d [[R3]], 0($4)
 308
 309   ret void
 310   ; CHECK: .size vshf_v2i64_3
 311 }
 312
 313 define void @vshf_v2i64_4(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 314   ; CHECK: vshf_v2i64_4:
 315
 316   %1 = load <2 x i64>* %a
 317   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 318   %2 = shufflevector <2 x i64> %1, <2 x i64> %1, <2 x i32> <i32 1, i32 3>
 319   ; CHECK-DAG: splati.d [[R3:\$w[0-9]+]], [[R1]][1]
 320   store <2 x i64> %2, <2 x i64>* %c
 321   ; CHECK-DAG: st.d [[R3]], 0($4)
 322
 323   ret void
 324   ; CHECK: .size vshf_v2i64_4
 325 }
 326
 327 define void @shf_v16i8_0(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 328   ; CHECK: shf_v16i8_0:
 329
 330   %1 = load <16 x i8>* %a
 331   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 332   %2 = shufflevector <16 x i8> %1, <16 x i8> undef, <16 x i32> <i32 1, i32 3, i32 2, i32 0, i32 5, i32 7, i32 6, i32 4, i32 9, i32 11, i32 10, i32 8, i32 13, i32 15, i32 14, i32 12>
 333   ; CHECK-DAG: shf.b [[R3:\$w[0-9]+]], [[R1]], 45
 334   store <16 x i8> %2, <16 x i8>* %c
 335   ; CHECK-DAG: st.b [[R3]], 0($4)
 336
 337   ret void
 338   ; CHECK: .size shf_v16i8_0
 339 }
 340
 341 define void @shf_v8i16_0(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 342   ; CHECK: shf_v8i16_0:
 343
 344   %1 = load <8 x i16>* %a
 345   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 346   %2 = shufflevector <8 x i16> %1, <8 x i16> undef, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4>
 347   ; CHECK-DAG: shf.h [[R3:\$w[0-9]+]], [[R1]], 27
 348   store <8 x i16> %2, <8 x i16>* %c
 349   ; CHECK-DAG: st.h [[R3]], 0($4)
 350
 351   ret void
 352   ; CHECK: .size shf_v8i16_0
 353 }
 354
 355 define void @shf_v4i32_0(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 356   ; CHECK: shf_v4i32_0:
 357
 358   %1 = load <4 x i32>* %a
 359   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 360   %2 = shufflevector <4 x i32> %1, <4 x i32> undef, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
 361   ; CHECK-DAG: shf.w [[R3:\$w[0-9]+]], [[R1]], 27
 362   store <4 x i32> %2, <4 x i32>* %c
 363   ; CHECK-DAG: st.w [[R3]], 0($4)
 364
 365   ret void
 366   ; CHECK: .size shf_v4i32_0
 367 }
 368
 369 ; shf.d does not exist
 370
 371 define void @ilvev_v16i8_0(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 372   ; CHECK: ilvev_v16i8_0:
 373
 374   %1 = load <16 x i8>* %a
 375   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 376   %2 = load <16 x i8>* %b
 377   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 378   %3 = shufflevector <16 x i8> %1, <16 x i8> %2,
 379                      <16 x i32> <i32 0, i32 16, i32 2, i32 18, i32 4, i32 20, i32 6, i32 22, i32 8, i32 24, i32 10, i32 26, i32 12, i32 28, i32 14, i32 30>
 380   ; CHECK-DAG: ilvev.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 381   store <16 x i8> %3, <16 x i8>* %c
 382   ; CHECK-DAG: st.b [[R3]], 0($4)
 383
 384   ret void
 385   ; CHECK: .size ilvev_v16i8_0
 386 }
 387
 388 define void @ilvev_v8i16_0(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 389   ; CHECK: ilvev_v8i16_0:
 390
 391   %1 = load <8 x i16>* %a
 392   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 393   %2 = load <8 x i16>* %b
 394   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 395   %3 = shufflevector <8 x i16> %1, <8 x i16> %2, <8 x i32> <i32 0, i32 8, i32 2, i32 10, i32 4, i32 12, i32 6, i32 14>
 396   ; CHECK-DAG: ilvev.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 397   store <8 x i16> %3, <8 x i16>* %c
 398   ; CHECK-DAG: st.h [[R3]], 0($4)
 399
 400   ret void
 401   ; CHECK: .size ilvev_v8i16_0
 402 }
 403
 404 define void @ilvev_v4i32_0(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 405   ; CHECK: ilvev_v4i32_0:
 406
 407   %1 = load <4 x i32>* %a
 408   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 409   %2 = load <4 x i32>* %b
 410   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 411   %3 = shufflevector <4 x i32> %1, <4 x i32> %2, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
 412   ; CHECK-DAG: ilvev.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 413   store <4 x i32> %3, <4 x i32>* %c
 414   ; CHECK-DAG: st.w [[R3]], 0($4)
 415
 416   ret void
 417   ; CHECK: .size ilvev_v4i32_0
 418 }
 419
 420 define void @ilvev_v2i64_0(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 421   ; CHECK: ilvev_v2i64_0:
 422
 423   %1 = load <2 x i64>* %a
 424   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 425   %2 = load <2 x i64>* %b
 426   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 427   %3 = shufflevector <2 x i64> %1, <2 x i64> %2, <2 x i32> <i32 0, i32 2>
 428   ; CHECK-DAG: ilvev.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 429   store <2 x i64> %3, <2 x i64>* %c
 430   ; CHECK-DAG: st.d [[R3]], 0($4)
 431
 432   ret void
 433   ; CHECK: .size ilvev_v2i64_0
 434 }
 435
 436 define void @ilvod_v16i8_0(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 437   ; CHECK: ilvod_v16i8_0:
 438
 439   %1 = load <16 x i8>* %a
 440   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 441   %2 = load <16 x i8>* %b
 442   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 443   %3 = shufflevector <16 x i8> %1, <16 x i8> %2,
 444                      <16 x i32> <i32 1, i32 17, i32 3, i32 19, i32 5, i32 21, i32 7, i32 23, i32 9, i32 25, i32 11, i32 27, i32 13, i32 29, i32 15, i32 31>
 445   ; CHECK-DAG: ilvod.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 446   store <16 x i8> %3, <16 x i8>* %c
 447   ; CHECK-DAG: st.b [[R3]], 0($4)
 448
 449   ret void
 450   ; CHECK: .size ilvod_v16i8_0
 451 }
 452
 453 define void @ilvod_v8i16_0(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 454   ; CHECK: ilvod_v8i16_0:
 455
 456   %1 = load <8 x i16>* %a
 457   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 458   %2 = load <8 x i16>* %b
 459   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 460   %3 = shufflevector <8 x i16> %1, <8 x i16> %2, <8 x i32> <i32 1, i32 9, i32 3, i32 11, i32 5, i32 13, i32 7, i32 15>
 461   ; CHECK-DAG: ilvod.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 462   store <8 x i16> %3, <8 x i16>* %c
 463   ; CHECK-DAG: st.h [[R3]], 0($4)
 464
 465   ret void
 466   ; CHECK: .size ilvod_v8i16_0
 467 }
 468
 469 define void @ilvod_v4i32_0(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 470   ; CHECK: ilvod_v4i32_0:
 471
 472   %1 = load <4 x i32>* %a
 473   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 474   %2 = load <4 x i32>* %b
 475   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 476   %3 = shufflevector <4 x i32> %1, <4 x i32> %2, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
 477   ; CHECK-DAG: ilvod.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 478   store <4 x i32> %3, <4 x i32>* %c
 479   ; CHECK-DAG: st.w [[R3]], 0($4)
 480
 481   ret void
 482   ; CHECK: .size ilvod_v4i32_0
 483 }
 484
 485 define void @ilvod_v2i64_0(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 486   ; CHECK: ilvod_v2i64_0:
 487
 488   %1 = load <2 x i64>* %a
 489   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 490   %2 = load <2 x i64>* %b
 491   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 492   %3 = shufflevector <2 x i64> %1, <2 x i64> %2, <2 x i32> <i32 1, i32 3>
 493   ; CHECK-DAG: ilvod.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 494   store <2 x i64> %3, <2 x i64>* %c
 495   ; CHECK-DAG: st.d [[R3]], 0($4)
 496
 497   ret void
 498   ; CHECK: .size ilvod_v2i64_0
 499 }
 500
 501 define void @ilvl_v16i8_0(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 502   ; CHECK: ilvl_v16i8_0:
 503
 504   %1 = load <16 x i8>* %a
 505   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 506   %2 = load <16 x i8>* %b
 507   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 508   %3 = shufflevector <16 x i8> %1, <16 x i8> %2,
 509                      <16 x i32> <i32 0, i32 16, i32 1, i32 17, i32 2, i32 18, i32 3, i32 19, i32 4, i32 20, i32 5, i32 21, i32 6, i32 22, i32 7, i32 23>
 510   ; CHECK-DAG: ilvl.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 511   store <16 x i8> %3, <16 x i8>* %c
 512   ; CHECK-DAG: st.b [[R3]], 0($4)
 513
 514   ret void
 515   ; CHECK: .size ilvl_v16i8_0
 516 }
 517
 518 define void @ilvl_v8i16_0(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 519   ; CHECK: ilvl_v8i16_0:
 520
 521   %1 = load <8 x i16>* %a
 522   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 523   %2 = load <8 x i16>* %b
 524   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 525   %3 = shufflevector <8 x i16> %1, <8 x i16> %2, <8 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11>
 526   ; CHECK-DAG: ilvl.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 527   store <8 x i16> %3, <8 x i16>* %c
 528   ; CHECK-DAG: st.h [[R3]], 0($4)
 529
 530   ret void
 531   ; CHECK: .size ilvl_v8i16_0
 532 }
 533
 534 define void @ilvl_v4i32_0(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 535   ; CHECK: ilvl_v4i32_0:
 536
 537   %1 = load <4 x i32>* %a
 538   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 539   %2 = load <4 x i32>* %b
 540   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 541   %3 = shufflevector <4 x i32> %1, <4 x i32> %2, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
 542   ; CHECK-DAG: ilvl.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 543   store <4 x i32> %3, <4 x i32>* %c
 544   ; CHECK-DAG: st.w [[R3]], 0($4)
 545
 546   ret void
 547   ; CHECK: .size ilvl_v4i32_0
 548 }
 549
 550 define void @ilvl_v2i64_0(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 551   ; CHECK: ilvl_v2i64_0:
 552
 553   %1 = load <2 x i64>* %a
 554   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 555   %2 = load <2 x i64>* %b
 556   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 557   %3 = shufflevector <2 x i64> %1, <2 x i64> %2, <2 x i32> <i32 0, i32 2>
 558   ; ilvl.d and ilvev.d are equivalent for v2i64
 559   ; CHECK-DAG: ilvev.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 560   store <2 x i64> %3, <2 x i64>* %c
 561   ; CHECK-DAG: st.d [[R3]], 0($4)
 562
 563   ret void
 564   ; CHECK: .size ilvl_v2i64_0
 565 }
 566
 567 define void @ilvr_v16i8_0(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 568   ; CHECK: ilvr_v16i8_0:
 569
 570   %1 = load <16 x i8>* %a
 571   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 572   %2 = load <16 x i8>* %b
 573   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 574   %3 = shufflevector <16 x i8> %1, <16 x i8> %2,
 575                      <16 x i32> <i32 8, i32 24, i32 9, i32 25, i32 10, i32 26, i32 11, i32 27, i32 12, i32 28, i32 13, i32 29, i32 14, i32 30, i32 15, i32 31>
 576   ; CHECK-DAG: ilvr.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 577   store <16 x i8> %3, <16 x i8>* %c
 578   ; CHECK-DAG: st.b [[R3]], 0($4)
 579
 580   ret void
 581   ; CHECK: .size ilvr_v16i8_0
 582 }
 583
 584 define void @ilvr_v8i16_0(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 585   ; CHECK: ilvr_v8i16_0:
 586
 587   %1 = load <8 x i16>* %a
 588   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 589   %2 = load <8 x i16>* %b
 590   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 591   %3 = shufflevector <8 x i16> %1, <8 x i16> %2, <8 x i32> <i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
 592   ; CHECK-DAG: ilvr.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 593   store <8 x i16> %3, <8 x i16>* %c
 594   ; CHECK-DAG: st.h [[R3]], 0($4)
 595
 596   ret void
 597   ; CHECK: .size ilvr_v8i16_0
 598 }
 599
 600 define void @ilvr_v4i32_0(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 601   ; CHECK: ilvr_v4i32_0:
 602
 603   %1 = load <4 x i32>* %a
 604   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 605   %2 = load <4 x i32>* %b
 606   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 607   %3 = shufflevector <4 x i32> %1, <4 x i32> %2, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
 608   ; CHECK-DAG: ilvr.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 609   store <4 x i32> %3, <4 x i32>* %c
 610   ; CHECK-DAG: st.w [[R3]], 0($4)
 611
 612   ret void
 613   ; CHECK: .size ilvr_v4i32_0
 614 }
 615
 616 define void @ilvr_v2i64_0(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 617   ; CHECK: ilvr_v2i64_0:
 618
 619   %1 = load <2 x i64>* %a
 620   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 621   %2 = load <2 x i64>* %b
 622   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 623   %3 = shufflevector <2 x i64> %1, <2 x i64> %2, <2 x i32> <i32 1, i32 3>
 624   ; ilvr.d and ilvod.d are equivalent for v2i64
 625   ; CHECK-DAG: ilvod.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 626   store <2 x i64> %3, <2 x i64>* %c
 627   ; CHECK-DAG: st.d [[R3]], 0($4)
 628
 629   ret void
 630   ; CHECK: .size ilvr_v2i64_0
 631 }
 632
 633 define void @pckev_v16i8_0(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 634   ; CHECK: pckev_v16i8_0:
 635
 636   %1 = load <16 x i8>* %a
 637   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 638   %2 = load <16 x i8>* %b
 639   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 640   %3 = shufflevector <16 x i8> %1, <16 x i8> %2,
 641                      <16 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14, i32 16, i32 18, i32 20, i32 22, i32 24, i32 26, i32 28, i32 30>
 642   ; CHECK-DAG: pckev.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 643   store <16 x i8> %3, <16 x i8>* %c
 644   ; CHECK-DAG: st.b [[R3]], 0($4)
 645
 646   ret void
 647   ; CHECK: .size pckev_v16i8_0
 648 }
 649
 650 define void @pckev_v8i16_0(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 651   ; CHECK: pckev_v8i16_0:
 652
 653   %1 = load <8 x i16>* %a
 654   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 655   %2 = load <8 x i16>* %b
 656   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 657   %3 = shufflevector <8 x i16> %1, <8 x i16> %2, <8 x i32> <i32 0, i32 2, i32 4, i32 6, i32 8, i32 10, i32 12, i32 14>
 658   ; CHECK-DAG: pckev.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 659   store <8 x i16> %3, <8 x i16>* %c
 660   ; CHECK-DAG: st.h [[R3]], 0($4)
 661
 662   ret void
 663   ; CHECK: .size pckev_v8i16_0
 664 }
 665
 666 define void @pckev_v4i32_0(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 667   ; CHECK: pckev_v4i32_0:
 668
 669   %1 = load <4 x i32>* %a
 670   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 671   %2 = load <4 x i32>* %b
 672   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 673   %3 = shufflevector <4 x i32> %1, <4 x i32> %2, <4 x i32> <i32 0, i32 2, i32 4, i32 6>
 674   ; CHECK-DAG: pckev.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 675   store <4 x i32> %3, <4 x i32>* %c
 676   ; CHECK-DAG: st.w [[R3]], 0($4)
 677
 678   ret void
 679   ; CHECK: .size pckev_v4i32_0
 680 }
 681
 682 define void @pckev_v2i64_0(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 683   ; CHECK: pckev_v2i64_0:
 684
 685   %1 = load <2 x i64>* %a
 686   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 687   %2 = load <2 x i64>* %b
 688   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 689   %3 = shufflevector <2 x i64> %1, <2 x i64> %2, <2 x i32> <i32 0, i32 2>
 690   ; pckev.d and ilvev.d are equivalent for v2i64
 691   ; CHECK-DAG: ilvev.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 692   store <2 x i64> %3, <2 x i64>* %c
 693   ; CHECK-DAG: st.d [[R3]], 0($4)
 694
 695   ret void
 696   ; CHECK: .size pckev_v2i64_0
 697 }
 698
 699 define void @pckod_v16i8_0(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 700   ; CHECK: pckod_v16i8_0:
 701
 702   %1 = load <16 x i8>* %a
 703   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 704   %2 = load <16 x i8>* %b
 705   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 706   %3 = shufflevector <16 x i8> %1, <16 x i8> %2,
 707                      <16 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15, i32 17, i32 19, i32 21, i32 23, i32 25, i32 27, i32 29, i32 31>
 708   ; CHECK-DAG: pckod.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 709   store <16 x i8> %3, <16 x i8>* %c
 710   ; CHECK-DAG: st.b [[R3]], 0($4)
 711
 712   ret void
 713   ; CHECK: .size pckod_v16i8_0
 714 }
 715
 716 define void @pckod_v8i16_0(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 717   ; CHECK: pckod_v8i16_0:
 718
 719   %1 = load <8 x i16>* %a
 720   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 721   %2 = load <8 x i16>* %b
 722   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 723   %3 = shufflevector <8 x i16> %1, <8 x i16> %2, <8 x i32> <i32 1, i32 3, i32 5, i32 7, i32 9, i32 11, i32 13, i32 15>
 724   ; CHECK-DAG: pckod.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 725   store <8 x i16> %3, <8 x i16>* %c
 726   ; CHECK-DAG: st.h [[R3]], 0($4)
 727
 728   ret void
 729   ; CHECK: .size pckod_v8i16_0
 730 }
 731
 732 define void @pckod_v4i32_0(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 733   ; CHECK: pckod_v4i32_0:
 734
 735   %1 = load <4 x i32>* %a
 736   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 737   %2 = load <4 x i32>* %b
 738   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 739   %3 = shufflevector <4 x i32> %1, <4 x i32> %2, <4 x i32> <i32 1, i32 3, i32 5, i32 7>
 740   ; CHECK-DAG: pckod.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 741   store <4 x i32> %3, <4 x i32>* %c
 742   ; CHECK-DAG: st.w [[R3]], 0($4)
 743
 744   ret void
 745   ; CHECK: .size pckod_v4i32_0
 746 }
 747
 748 define void @pckod_v2i64_0(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 749   ; CHECK: pckod_v2i64_0:
 750
 751   %1 = load <2 x i64>* %a
 752   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 753   %2 = load <2 x i64>* %b
 754   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 755   %3 = shufflevector <2 x i64> %1, <2 x i64> %2, <2 x i32> <i32 1, i32 3>
 756   ; pckod.d and ilvod.d are equivalent for v2i64
 757   ; CHECK-DAG: ilvod.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 758   store <2 x i64> %3, <2 x i64>* %c
 759   ; CHECK-DAG: st.d [[R3]], 0($4)
 760
 761   ret void
 762   ; CHECK: .size pckod_v2i64_0
 763 }
 764
 765 define void @splati_v16i8_0(<16 x i8>* %c, <16 x i8>* %a) nounwind {
 766   ; CHECK: splati_v16i8_0:
 767
 768   %1 = load <16 x i8>* %a
 769   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 770   %2 = shufflevector <16 x i8> %1, <16 x i8> undef,
 771                      <16 x i32> <i32 4, i32 4, i32 4, i32 4, i32 4, i32 4, i32 4, i32 4, i32 4, i32 4, i32 4, i32 4, i32 4, i32 4, i32 4, i32 4>
 772   ; CHECK-DAG: splati.b [[R3:\$w[0-9]+]], [[R1]][4]
 773   store <16 x i8> %2, <16 x i8>* %c
 774   ; CHECK-DAG: st.b [[R3]], 0($4)
 775
 776   ret void
 777   ; CHECK: .size splati_v16i8_0
 778 }
 779
 780 define void @splati_v8i16_0(<8 x i16>* %c, <8 x i16>* %a) nounwind {
 781   ; CHECK: splati_v8i16_0:
 782
 783   %1 = load <8 x i16>* %a
 784   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 785   %2 = shufflevector <8 x i16> %1, <8 x i16> undef, <8 x i32> <i32 4, i32 4, i32 4, i32 4, i32 4, i32 4, i32 4, i32 4>
 786   ; CHECK-DAG: splati.h [[R3:\$w[0-9]+]], [[R1]][4]
 787   store <8 x i16> %2, <8 x i16>* %c
 788   ; CHECK-DAG: st.h [[R3]], 0($4)
 789
 790   ret void
 791   ; CHECK: .size splati_v8i16_0
 792 }
 793
 794 define void @splati_v4i32_0(<4 x i32>* %c, <4 x i32>* %a) nounwind {
 795   ; CHECK: splati_v4i32_0:
 796
 797   %1 = load <4 x i32>* %a
 798   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 799   %2 = shufflevector <4 x i32> %1, <4 x i32> undef, <4 x i32> <i32 3, i32 3, i32 3, i32 3>
 800   ; shf.w and splati.w are equivalent
 801   ; CHECK-DAG: shf.w [[R3:\$w[0-9]+]], [[R1]], 255
 802   store <4 x i32> %2, <4 x i32>* %c
 803   ; CHECK-DAG: st.w [[R3]], 0($4)
 804
 805   ret void
 806   ; CHECK: .size splati_v4i32_0
 807 }
 808
 809 define void @splati_v2i64_0(<2 x i64>* %c, <2 x i64>* %a) nounwind {
 810   ; CHECK: splati_v2i64_0:
 811
 812   %1 = load <2 x i64>* %a
 813   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 814   %2 = shufflevector <2 x i64> %1, <2 x i64> undef, <2 x i32> <i32 1, i32 1>
 815   ; CHECK-DAG: splati.d [[R3:\$w[0-9]+]], [[R1]][1]
 816   store <2 x i64> %2, <2 x i64>* %c
 817   ; CHECK-DAG: st.d [[R3]], 0($4)
 818
 819   ret void
 820   ; CHECK: .size splati_v2i64_0
 821 }