test/CodeGen/Mips/msa/shuffle.ll

   1 ; RUN: llc -march=mips -mattr=+msa < %s | FileCheck %s
   2
   3 define void @vshf_v16i8_0(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
   4   ; CHECK: vshf_v16i8_0:
   5
   6   %1 = load <16 x i8>* %a
   7   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
   8   %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>
   9   ; CHECK-DAG: ld.b [[R3:\$w[0-9]+]], %lo
  10   ; CHECK-DAG: vshf.b [[R3]], [[R1]], [[R1]]
  11   store <16 x i8> %2, <16 x i8>* %c
  12   ; CHECK-DAG: st.b [[R3]], 0($4)
  13
  14   ret void
  15   ; CHECK: .size vshf_v16i8_0
  16 }
  17
  18 define void @vshf_v16i8_1(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
  19   ; CHECK: vshf_v16i8_1:
  20
  21   %1 = load <16 x i8>* %a
  22   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
  23   %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>
  24   ; CHECK-DAG: ldi.b [[R3:\$w[0-9]+]], 1
  25   ; CHECK-DAG: vshf.b [[R3]], [[R1]], [[R1]]
  26   store <16 x i8> %2, <16 x i8>* %c
  27   ; CHECK-DAG: st.b [[R3]], 0($4)
  28
  29   ret void
  30   ; CHECK: .size vshf_v16i8_1
  31 }
  32
  33 define void @vshf_v16i8_2(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
  34   ; CHECK: vshf_v16i8_2:
  35
  36   %1 = load <16 x i8>* %a
  37   %2 = load <16 x i8>* %b
  38   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
  39   %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>
  40   ; CHECK-DAG: ld.b [[R3:\$w[0-9]+]], %lo
  41   ; CHECK-DAG: vshf.b [[R3]], [[R2]], [[R2]]
  42   store <16 x i8> %3, <16 x i8>* %c
  43   ; CHECK-DAG: st.b [[R3]], 0($4)
  44
  45   ret void
  46   ; CHECK: .size vshf_v16i8_2
  47 }
  48
  49 define void @vshf_v16i8_3(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
  50   ; CHECK: vshf_v16i8_3:
  51
  52   %1 = load <16 x i8>* %a
  53   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
  54   %2 = load <16 x i8>* %b
  55   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
  56   %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>
  57   ; CHECK-DAG: ld.b [[R3:\$w[0-9]+]], %lo
  58   ; CHECK-DAG: vshf.b [[R3]], [[R1]], [[R2]]
  59   store <16 x i8> %3, <16 x i8>* %c
  60   ; CHECK-DAG: st.b [[R3]], 0($4)
  61
  62   ret void
  63   ; CHECK: .size vshf_v16i8_3
  64 }
  65
  66 define void @vshf_v16i8_4(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
  67   ; CHECK: vshf_v16i8_4:
  68
  69   %1 = load <16 x i8>* %a
  70   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
  71   %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>
  72   ; CHECK-DAG: ldi.b [[R3:\$w[0-9]+]], 1
  73   ; CHECK-DAG: vshf.b [[R3]], [[R1]], [[R1]]
  74   store <16 x i8> %2, <16 x i8>* %c
  75   ; CHECK-DAG: st.b [[R3]], 0($4)
  76
  77   ret void
  78   ; CHECK: .size vshf_v16i8_4
  79 }
  80
  81 define void @vshf_v8i16_0(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
  82   ; CHECK: vshf_v8i16_0:
  83
  84   %1 = load <8 x i16>* %a
  85   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
  86   %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>
  87   ; CHECK-DAG: ld.h [[R3:\$w[0-9]+]], %lo
  88   ; CHECK-DAG: vshf.h [[R3]], [[R1]], [[R1]]
  89   store <8 x i16> %2, <8 x i16>* %c
  90   ; CHECK-DAG: st.h [[R3]], 0($4)
  91
  92   ret void
  93   ; CHECK: .size vshf_v8i16_0
  94 }
  95
  96 define void @vshf_v8i16_1(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
  97   ; CHECK: vshf_v8i16_1:
  98
  99   %1 = load <8 x i16>* %a
 100   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 101   %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>
 102   ; CHECK-DAG: ldi.h [[R3:\$w[0-9]+]], 1
 103   ; CHECK-DAG: vshf.h [[R3]], [[R1]], [[R1]]
 104   store <8 x i16> %2, <8 x i16>* %c
 105   ; CHECK-DAG: st.h [[R3]], 0($4)
 106
 107   ret void
 108   ; CHECK: .size vshf_v8i16_1
 109 }
 110
 111 define void @vshf_v8i16_2(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 112   ; CHECK: vshf_v8i16_2:
 113
 114   %1 = load <8 x i16>* %a
 115   %2 = load <8 x i16>* %b
 116   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 117   %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>
 118   ; CHECK-DAG: ld.h [[R3:\$w[0-9]+]], %lo
 119   ; CHECK-DAG: vshf.h [[R3]], [[R2]], [[R2]]
 120   store <8 x i16> %3, <8 x i16>* %c
 121   ; CHECK-DAG: st.h [[R3]], 0($4)
 122
 123   ret void
 124   ; CHECK: .size vshf_v8i16_2
 125 }
 126
 127 define void @vshf_v8i16_3(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 128   ; CHECK: vshf_v8i16_3:
 129
 130   %1 = load <8 x i16>* %a
 131   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 132   %2 = load <8 x i16>* %b
 133   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 134   %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>
 135   ; CHECK-DAG: ld.h [[R3:\$w[0-9]+]], %lo
 136   ; CHECK-DAG: vshf.h [[R3]], [[R1]], [[R2]]
 137   store <8 x i16> %3, <8 x i16>* %c
 138   ; CHECK-DAG: st.h [[R3]], 0($4)
 139
 140   ret void
 141   ; CHECK: .size vshf_v8i16_3
 142 }
 143
 144 define void @vshf_v8i16_4(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 145   ; CHECK: vshf_v8i16_4:
 146
 147   %1 = load <8 x i16>* %a
 148   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 149   %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>
 150   ; CHECK-DAG: ldi.h [[R3:\$w[0-9]+]], 1
 151   ; CHECK-DAG: vshf.h [[R3]], [[R1]], [[R1]]
 152   store <8 x i16> %2, <8 x i16>* %c
 153   ; CHECK-DAG: st.h [[R3]], 0($4)
 154
 155   ret void
 156   ; CHECK: .size vshf_v8i16_4
 157 }
 158
 159 ; Note: v4i32 only has one 4-element set so it's impossible to get a vshf.w
 160 ; instruction when using a single vector.
 161
 162 define void @vshf_v4i32_0(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 163   ; CHECK: vshf_v4i32_0:
 164
 165   %1 = load <4 x i32>* %a
 166   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 167   %2 = shufflevector <4 x i32> %1, <4 x i32> undef, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
 168   ; CHECK-DAG: shf.w [[R3:\$w[0-9]+]], [[R1]], 27
 169   store <4 x i32> %2, <4 x i32>* %c
 170   ; CHECK-DAG: st.w [[R3]], 0($4)
 171
 172   ret void
 173   ; CHECK: .size vshf_v4i32_0
 174 }
 175
 176 define void @vshf_v4i32_1(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 177   ; CHECK: vshf_v4i32_1:
 178
 179   %1 = load <4 x i32>* %a
 180   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 181   %2 = shufflevector <4 x i32> %1, <4 x i32> undef, <4 x i32> <i32 1, i32 1, i32 1, i32 1>
 182   ; CHECK-DAG: shf.w [[R3:\$w[0-9]+]], [[R1]], 85
 183   store <4 x i32> %2, <4 x i32>* %c
 184   ; CHECK-DAG: st.w [[R3]], 0($4)
 185
 186   ret void
 187   ; CHECK: .size vshf_v4i32_1
 188 }
 189
 190 define void @vshf_v4i32_2(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 191   ; CHECK: vshf_v4i32_2:
 192
 193   %1 = load <4 x i32>* %a
 194   %2 = load <4 x i32>* %b
 195   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 196   %3 = shufflevector <4 x i32> %1, <4 x i32> %2, <4 x i32> <i32 4, i32 5, i32 6, i32 4>
 197   ; CHECK-DAG: shf.w [[R3:\$w[0-9]+]], [[R2]], 36
 198   store <4 x i32> %3, <4 x i32>* %c
 199   ; CHECK-DAG: st.w [[R3]], 0($4)
 200
 201   ret void
 202   ; CHECK: .size vshf_v4i32_2
 203 }
 204
 205 define void @vshf_v4i32_3(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 206   ; CHECK: vshf_v4i32_3:
 207
 208   %1 = load <4 x i32>* %a
 209   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 210   %2 = load <4 x i32>* %b
 211   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 212   %3 = shufflevector <4 x i32> %1, <4 x i32> %2, <4 x i32> <i32 1, i32 5, i32 6, i32 4>
 213   ; CHECK-DAG: ld.w [[R3:\$w[0-9]+]], %lo
 214   ; CHECK-DAG: vshf.w [[R3]], [[R1]], [[R2]]
 215   store <4 x i32> %3, <4 x i32>* %c
 216   ; CHECK-DAG: st.w [[R3]], 0($4)
 217
 218   ret void
 219   ; CHECK: .size vshf_v4i32_3
 220 }
 221
 222 define void @vshf_v4i32_4(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 223   ; CHECK: vshf_v4i32_4:
 224
 225   %1 = load <4 x i32>* %a
 226   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 227   %2 = shufflevector <4 x i32> %1, <4 x i32> %1, <4 x i32> <i32 1, i32 5, i32 5, i32 1>
 228   ; CHECK-DAG: shf.w [[R3:\$w[0-9]+]], [[R1]], 85
 229   store <4 x i32> %2, <4 x i32>* %c
 230   ; CHECK-DAG: st.w [[R3]], 0($4)
 231
 232   ret void
 233   ; CHECK: .size vshf_v4i32_4
 234 }
 235
 236 define void @vshf_v2i64_0(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 237   ; CHECK: vshf_v2i64_0:
 238
 239   %1 = load <2 x i64>* %a
 240   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 241   %2 = shufflevector <2 x i64> %1, <2 x i64> undef, <2 x i32> <i32 1, i32 0>
 242   ; CHECK-DAG: ld.d [[R3:\$w[0-9]+]], %lo
 243   ; CHECK-DAG: vshf.d [[R3]], [[R1]], [[R1]]
 244   store <2 x i64> %2, <2 x i64>* %c
 245   ; CHECK-DAG: st.d [[R3]], 0($4)
 246
 247   ret void
 248   ; CHECK: .size vshf_v2i64_0
 249 }
 250
 251 define void @vshf_v2i64_1(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 252   ; CHECK: vshf_v2i64_1:
 253
 254   %1 = load <2 x i64>* %a
 255   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 256   %2 = shufflevector <2 x i64> %1, <2 x i64> undef, <2 x i32> <i32 1, i32 1>
 257   ; CHECK-DAG: ldi.d [[R3:\$w[0-9]+]], 1
 258   ; CHECK-DAG: vshf.d [[R3]], [[R1]], [[R1]]
 259   store <2 x i64> %2, <2 x i64>* %c
 260   ; CHECK-DAG: st.d [[R3]], 0($4)
 261
 262   ret void
 263   ; CHECK: .size vshf_v2i64_1
 264 }
 265
 266 define void @vshf_v2i64_2(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 267   ; CHECK: vshf_v2i64_2:
 268
 269   %1 = load <2 x i64>* %a
 270   %2 = load <2 x i64>* %b
 271   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 272   %3 = shufflevector <2 x i64> %1, <2 x i64> %2, <2 x i32> <i32 3, i32 2>
 273   ; CHECK-DAG: ld.d [[R3:\$w[0-9]+]], %lo
 274   ; CHECK-DAG: vshf.d [[R3]], [[R2]], [[R2]]
 275   store <2 x i64> %3, <2 x i64>* %c
 276   ; CHECK-DAG: st.d [[R3]], 0($4)
 277
 278   ret void
 279   ; CHECK: .size vshf_v2i64_2
 280 }
 281
 282 define void @vshf_v2i64_3(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 283   ; CHECK: vshf_v2i64_3:
 284
 285   %1 = load <2 x i64>* %a
 286   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 287   %2 = load <2 x i64>* %b
 288   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 289   %3 = shufflevector <2 x i64> %1, <2 x i64> %2, <2 x i32> <i32 1, i32 2>
 290   ; CHECK-DAG: ld.d [[R3:\$w[0-9]+]], %lo
 291   ; CHECK-DAG: vshf.d [[R3]], [[R1]], [[R2]]
 292   store <2 x i64> %3, <2 x i64>* %c
 293   ; CHECK-DAG: st.d [[R3]], 0($4)
 294
 295   ret void
 296   ; CHECK: .size vshf_v2i64_3
 297 }
 298
 299 define void @vshf_v2i64_4(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 300   ; CHECK: vshf_v2i64_4:
 301
 302   %1 = load <2 x i64>* %a
 303   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 304   %2 = shufflevector <2 x i64> %1, <2 x i64> %1, <2 x i32> <i32 1, i32 3>
 305   ; CHECK-DAG: ldi.d [[R3:\$w[0-9]+]], 1
 306   ; CHECK-DAG: vshf.d [[R3]], [[R1]], [[R1]]
 307   store <2 x i64> %2, <2 x i64>* %c
 308   ; CHECK-DAG: st.d [[R3]], 0($4)
 309
 310   ret void
 311   ; CHECK: .size vshf_v2i64_4
 312 }
 313
 314 define void @shf_v16i8_0(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 315   ; CHECK: shf_v16i8_0:
 316
 317   %1 = load <16 x i8>* %a
 318   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 319   %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>
 320   ; CHECK-DAG: shf.b [[R3:\$w[0-9]+]], [[R1]], 45
 321   store <16 x i8> %2, <16 x i8>* %c
 322   ; CHECK-DAG: st.b [[R3]], 0($4)
 323
 324   ret void
 325   ; CHECK: .size shf_v16i8_0
 326 }
 327
 328 define void @shf_v8i16_0(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 329   ; CHECK: shf_v8i16_0:
 330
 331   %1 = load <8 x i16>* %a
 332   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 333   %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>
 334   ; CHECK-DAG: shf.h [[R3:\$w[0-9]+]], [[R1]], 27
 335   store <8 x i16> %2, <8 x i16>* %c
 336   ; CHECK-DAG: st.h [[R3]], 0($4)
 337
 338   ret void
 339   ; CHECK: .size shf_v8i16_0
 340 }
 341
 342 define void @shf_v4i32_0(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 343   ; CHECK: shf_v4i32_0:
 344
 345   %1 = load <4 x i32>* %a
 346   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 347   %2 = shufflevector <4 x i32> %1, <4 x i32> undef, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
 348   ; CHECK-DAG: shf.w [[R3:\$w[0-9]+]], [[R1]], 27
 349   store <4 x i32> %2, <4 x i32>* %c
 350   ; CHECK-DAG: st.w [[R3]], 0($4)
 351
 352   ret void
 353   ; CHECK: .size shf_v4i32_0
 354 }
 355
 356 ; shf.d does not exist
 357
 358 define void @ilvev_v16i8_0(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 359   ; CHECK: ilvev_v16i8_0:
 360
 361   %1 = load <16 x i8>* %a
 362   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 363   %2 = load <16 x i8>* %b
 364   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 365   %3 = shufflevector <16 x i8> %1, <16 x i8> %2,
 366                      <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>
 367   ; CHECK-DAG: ilvev.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 368   store <16 x i8> %3, <16 x i8>* %c
 369   ; CHECK-DAG: st.b [[R3]], 0($4)
 370
 371   ret void
 372   ; CHECK: .size ilvev_v16i8_0
 373 }
 374
 375 define void @ilvev_v8i16_0(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 376   ; CHECK: ilvev_v8i16_0:
 377
 378   %1 = load <8 x i16>* %a
 379   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 380   %2 = load <8 x i16>* %b
 381   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 382   %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>
 383   ; CHECK-DAG: ilvev.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 384   store <8 x i16> %3, <8 x i16>* %c
 385   ; CHECK-DAG: st.h [[R3]], 0($4)
 386
 387   ret void
 388   ; CHECK: .size ilvev_v8i16_0
 389 }
 390
 391 define void @ilvev_v4i32_0(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 392   ; CHECK: ilvev_v4i32_0:
 393
 394   %1 = load <4 x i32>* %a
 395   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 396   %2 = load <4 x i32>* %b
 397   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 398   %3 = shufflevector <4 x i32> %1, <4 x i32> %2, <4 x i32> <i32 0, i32 4, i32 2, i32 6>
 399   ; CHECK-DAG: ilvev.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 400   store <4 x i32> %3, <4 x i32>* %c
 401   ; CHECK-DAG: st.w [[R3]], 0($4)
 402
 403   ret void
 404   ; CHECK: .size ilvev_v4i32_0
 405 }
 406
 407 define void @ilvev_v2i64_0(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 408   ; CHECK: ilvev_v2i64_0:
 409
 410   %1 = load <2 x i64>* %a
 411   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 412   %2 = load <2 x i64>* %b
 413   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 414   %3 = shufflevector <2 x i64> %1, <2 x i64> %2, <2 x i32> <i32 0, i32 2>
 415   ; CHECK-DAG: ilvev.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 416   store <2 x i64> %3, <2 x i64>* %c
 417   ; CHECK-DAG: st.d [[R3]], 0($4)
 418
 419   ret void
 420   ; CHECK: .size ilvev_v2i64_0
 421 }
 422
 423 define void @ilvod_v16i8_0(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 424   ; CHECK: ilvod_v16i8_0:
 425
 426   %1 = load <16 x i8>* %a
 427   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 428   %2 = load <16 x i8>* %b
 429   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 430   %3 = shufflevector <16 x i8> %1, <16 x i8> %2,
 431                      <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>
 432   ; CHECK-DAG: ilvod.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 433   store <16 x i8> %3, <16 x i8>* %c
 434   ; CHECK-DAG: st.b [[R3]], 0($4)
 435
 436   ret void
 437   ; CHECK: .size ilvod_v16i8_0
 438 }
 439
 440 define void @ilvod_v8i16_0(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 441   ; CHECK: ilvod_v8i16_0:
 442
 443   %1 = load <8 x i16>* %a
 444   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 445   %2 = load <8 x i16>* %b
 446   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 447   %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>
 448   ; CHECK-DAG: ilvod.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 449   store <8 x i16> %3, <8 x i16>* %c
 450   ; CHECK-DAG: st.h [[R3]], 0($4)
 451
 452   ret void
 453   ; CHECK: .size ilvod_v8i16_0
 454 }
 455
 456 define void @ilvod_v4i32_0(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 457   ; CHECK: ilvod_v4i32_0:
 458
 459   %1 = load <4 x i32>* %a
 460   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 461   %2 = load <4 x i32>* %b
 462   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 463   %3 = shufflevector <4 x i32> %1, <4 x i32> %2, <4 x i32> <i32 1, i32 5, i32 3, i32 7>
 464   ; CHECK-DAG: ilvod.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 465   store <4 x i32> %3, <4 x i32>* %c
 466   ; CHECK-DAG: st.w [[R3]], 0($4)
 467
 468   ret void
 469   ; CHECK: .size ilvod_v4i32_0
 470 }
 471
 472 define void @ilvod_v2i64_0(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 473   ; CHECK: ilvod_v2i64_0:
 474
 475   %1 = load <2 x i64>* %a
 476   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 477   %2 = load <2 x i64>* %b
 478   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 479   %3 = shufflevector <2 x i64> %1, <2 x i64> %2, <2 x i32> <i32 1, i32 3>
 480   ; CHECK-DAG: ilvod.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 481   store <2 x i64> %3, <2 x i64>* %c
 482   ; CHECK-DAG: st.d [[R3]], 0($4)
 483
 484   ret void
 485   ; CHECK: .size ilvod_v2i64_0
 486 }
 487
 488 define void @ilvl_v16i8_0(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 489   ; CHECK: ilvl_v16i8_0:
 490
 491   %1 = load <16 x i8>* %a
 492   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 493   %2 = load <16 x i8>* %b
 494   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 495   %3 = shufflevector <16 x i8> %1, <16 x i8> %2,
 496                      <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>
 497   ; CHECK-DAG: ilvl.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 498   store <16 x i8> %3, <16 x i8>* %c
 499   ; CHECK-DAG: st.b [[R3]], 0($4)
 500
 501   ret void
 502   ; CHECK: .size ilvl_v16i8_0
 503 }
 504
 505 define void @ilvl_v8i16_0(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 506   ; CHECK: ilvl_v8i16_0:
 507
 508   %1 = load <8 x i16>* %a
 509   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 510   %2 = load <8 x i16>* %b
 511   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 512   %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>
 513   ; CHECK-DAG: ilvl.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 514   store <8 x i16> %3, <8 x i16>* %c
 515   ; CHECK-DAG: st.h [[R3]], 0($4)
 516
 517   ret void
 518   ; CHECK: .size ilvl_v8i16_0
 519 }
 520
 521 define void @ilvl_v4i32_0(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 522   ; CHECK: ilvl_v4i32_0:
 523
 524   %1 = load <4 x i32>* %a
 525   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 526   %2 = load <4 x i32>* %b
 527   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 528   %3 = shufflevector <4 x i32> %1, <4 x i32> %2, <4 x i32> <i32 0, i32 4, i32 1, i32 5>
 529   ; CHECK-DAG: ilvl.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 530   store <4 x i32> %3, <4 x i32>* %c
 531   ; CHECK-DAG: st.w [[R3]], 0($4)
 532
 533   ret void
 534   ; CHECK: .size ilvl_v4i32_0
 535 }
 536
 537 define void @ilvl_v2i64_0(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 538   ; CHECK: ilvl_v2i64_0:
 539
 540   %1 = load <2 x i64>* %a
 541   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 542   %2 = load <2 x i64>* %b
 543   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 544   %3 = shufflevector <2 x i64> %1, <2 x i64> %2, <2 x i32> <i32 0, i32 2>
 545   ; ilvl.d and ilvev.d are equivalent for v2i64
 546   ; CHECK-DAG: ilvev.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 547   store <2 x i64> %3, <2 x i64>* %c
 548   ; CHECK-DAG: st.d [[R3]], 0($4)
 549
 550   ret void
 551   ; CHECK: .size ilvl_v2i64_0
 552 }
 553
 554 define void @ilvr_v16i8_0(<16 x i8>* %c, <16 x i8>* %a, <16 x i8>* %b) nounwind {
 555   ; CHECK: ilvr_v16i8_0:
 556
 557   %1 = load <16 x i8>* %a
 558   ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)
 559   %2 = load <16 x i8>* %b
 560   ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)
 561   %3 = shufflevector <16 x i8> %1, <16 x i8> %2,
 562                      <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>
 563   ; CHECK-DAG: ilvr.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 564   store <16 x i8> %3, <16 x i8>* %c
 565   ; CHECK-DAG: st.b [[R3]], 0($4)
 566
 567   ret void
 568   ; CHECK: .size ilvr_v16i8_0
 569 }
 570
 571 define void @ilvr_v8i16_0(<8 x i16>* %c, <8 x i16>* %a, <8 x i16>* %b) nounwind {
 572   ; CHECK: ilvr_v8i16_0:
 573
 574   %1 = load <8 x i16>* %a
 575   ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)
 576   %2 = load <8 x i16>* %b
 577   ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)
 578   %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>
 579   ; CHECK-DAG: ilvr.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 580   store <8 x i16> %3, <8 x i16>* %c
 581   ; CHECK-DAG: st.h [[R3]], 0($4)
 582
 583   ret void
 584   ; CHECK: .size ilvr_v8i16_0
 585 }
 586
 587 define void @ilvr_v4i32_0(<4 x i32>* %c, <4 x i32>* %a, <4 x i32>* %b) nounwind {
 588   ; CHECK: ilvr_v4i32_0:
 589
 590   %1 = load <4 x i32>* %a
 591   ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)
 592   %2 = load <4 x i32>* %b
 593   ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)
 594   %3 = shufflevector <4 x i32> %1, <4 x i32> %2, <4 x i32> <i32 2, i32 6, i32 3, i32 7>
 595   ; CHECK-DAG: ilvr.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 596   store <4 x i32> %3, <4 x i32>* %c
 597   ; CHECK-DAG: st.w [[R3]], 0($4)
 598
 599   ret void
 600   ; CHECK: .size ilvr_v4i32_0
 601 }
 602
 603 define void @ilvr_v2i64_0(<2 x i64>* %c, <2 x i64>* %a, <2 x i64>* %b) nounwind {
 604   ; CHECK: ilvr_v2i64_0:
 605
 606   %1 = load <2 x i64>* %a
 607   ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)
 608   %2 = load <2 x i64>* %b
 609   ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)
 610   %3 = shufflevector <2 x i64> %1, <2 x i64> %2, <2 x i32> <i32 1, i32 3>
 611   ; ilvr.d and ilvod.d are equivalent for v2i64
 612   ; CHECK-DAG: ilvod.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]
 613   store <2 x i64> %3, <2 x i64>* %c
 614   ; CHECK-DAG: st.d [[R3]], 0($4)
 615
 616   ret void
 617   ; CHECK: .size ilvr_v2i64_0
 618 }