test/Transforms/InstCombine/vec_shuffle.ll

   1 ; RUN: opt < %s -instcombine -S | FileCheck %s
   2
   3 define <4 x float> @test1(<4 x float> %v1) {
   4 ; CHECK: @test1
   5 ; CHECK: ret <4 x float> %v1
   6   %v2 = shufflevector <4 x float> %v1, <4 x float> undef, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
   7   ret <4 x float> %v2
   8 }
   9
  10 define <4 x float> @test2(<4 x float> %v1) {
  11 ; CHECK: @test2
  12 ; CHECK: ret <4 x float> %v1
  13   %v2 = shufflevector <4 x float> %v1, <4 x float> %v1, <4 x i32> <i32 0, i32 5, i32 2, i32 7>
  14   ret <4 x float> %v2
  15 }
  16
  17 define float @test3(<4 x float> %A, <4 x float> %B, float %f) {
  18 ; CHECK: @test3
  19 ; CHECK: ret float %f
  20         %C = insertelement <4 x float> %A, float %f, i32 0
  21         %D = shufflevector <4 x float> %C, <4 x float> %B, <4 x i32> <i32 5, i32 0, i32 2, i32 7>
  22         %E = extractelement <4 x float> %D, i32 1
  23         ret float %E
  24 }
  25
  26 define i32 @test4(<4 x i32> %X) {
  27 ; CHECK: @test4
  28 ; CHECK-NEXT: extractelement
  29 ; CHECK-NEXT: ret
  30         %tmp152.i53899.i = shufflevector <4 x i32> %X, <4 x i32> undef, <4 x i32> zeroinitializer
  31         %tmp34 = extractelement <4 x i32> %tmp152.i53899.i, i32 0
  32         ret i32 %tmp34
  33 }
  34
  35 define i32 @test5(<4 x i32> %X) {
  36 ; CHECK: @test5
  37 ; CHECK-NEXT: extractelement
  38 ; CHECK-NEXT: ret
  39         %tmp152.i53899.i = shufflevector <4 x i32> %X, <4 x i32> undef, <4 x i32> <i32 3, i32 2, i32 undef, i32 undef>
  40         %tmp34 = extractelement <4 x i32> %tmp152.i53899.i, i32 0
  41         ret i32 %tmp34
  42 }
  43
  44 define float @test6(<4 x float> %X) {
  45 ; CHECK: @test6
  46 ; CHECK-NEXT: extractelement
  47 ; CHECK-NEXT: ret
  48         %X1 = bitcast <4 x float> %X to <4 x i32>
  49         %tmp152.i53899.i = shufflevector <4 x i32> %X1, <4 x i32> undef, <4 x i32> zeroinitializer
  50         %tmp152.i53900.i = bitcast <4 x i32> %tmp152.i53899.i to <4 x float>
  51         %tmp34 = extractelement <4 x float> %tmp152.i53900.i, i32 0
  52         ret float %tmp34
  53 }
  54
  55 define <4 x float> @test7(<4 x float> %tmp45.i) {
  56 ; CHECK: @test7
  57 ; CHECK-NEXT: ret <4 x float> %tmp45.i
  58         %tmp1642.i = shufflevector <4 x float> %tmp45.i, <4 x float> undef, <4 x i32> < i32 0, i32 1, i32 6, i32 7 >
  59         ret <4 x float> %tmp1642.i
  60 }
  61
  62 ; This should turn into a single shuffle.
  63 define <4 x float> @test8(<4 x float> %tmp, <4 x float> %tmp1) {
  64 ; CHECK: @test8
  65 ; CHECK-NEXT: shufflevector
  66 ; CHECK-NEXT: ret
  67         %tmp4 = extractelement <4 x float> %tmp, i32 1
  68         %tmp2 = extractelement <4 x float> %tmp, i32 3
  69         %tmp1.upgrd.1 = extractelement <4 x float> %tmp1, i32 0
  70         %tmp128 = insertelement <4 x float> undef, float %tmp4, i32 0
  71         %tmp130 = insertelement <4 x float> %tmp128, float undef, i32 1
  72         %tmp132 = insertelement <4 x float> %tmp130, float %tmp2, i32 2
  73         %tmp134 = insertelement <4 x float> %tmp132, float %tmp1.upgrd.1, i32 3
  74         ret <4 x float> %tmp134
  75 }
  76
  77 ; Test fold of two shuffles where the first shuffle vectors inputs are a
  78 ; different length then the second.
  79 define <4 x i8> @test9(<16 x i8> %tmp6) nounwind {
  80 ; CHECK: @test9
  81 ; CHECK-NEXT: shufflevector
  82 ; CHECK-NEXT: ret
  83         %tmp7 = shufflevector <16 x i8> %tmp6, <16 x i8> undef, <4 x i32> < i32 13, i32 9, i32 4, i32 13 >              ; <<4 x i8>> [#uses=1]
  84         %tmp9 = shufflevector <4 x i8> %tmp7, <4 x i8> undef, <4 x i32> < i32 3, i32 1, i32 2, i32 0 >          ; <<4 x i8>> [#uses=1]
  85         ret <4 x i8> %tmp9
  86 }
  87
  88 ; Same as test9, but make sure that "undef" mask values are not confused with
  89 ; mask values of 2*N, where N is the mask length.  These shuffles should not
  90 ; be folded (because [8,9,4,8] may not be a mask supported by the target).
  91 define <4 x i8> @test9a(<16 x i8> %tmp6) nounwind {
  92 ; CHECK: @test9a
  93 ; CHECK-NEXT: shufflevector
  94 ; CHECK-NEXT: shufflevector
  95 ; CHECK-NEXT: ret
  96         %tmp7 = shufflevector <16 x i8> %tmp6, <16 x i8> undef, <4 x i32> < i32 undef, i32 9, i32 4, i32 8 >            ; <<4 x i8>> [#uses=1]
  97         %tmp9 = shufflevector <4 x i8> %tmp7, <4 x i8> undef, <4 x i32> < i32 3, i32 1, i32 2, i32 0 >          ; <<4 x i8>> [#uses=1]
  98         ret <4 x i8> %tmp9
  99 }
 100
 101 ; Test fold of two shuffles where the first shuffle vectors inputs are a
 102 ; different length then the second.
 103 define <4 x i8> @test9b(<4 x i8> %tmp6, <4 x i8> %tmp7) nounwind {
 104 ; CHECK: @test9b
 105 ; CHECK-NEXT: shufflevector
 106 ; CHECK-NEXT: ret
 107   %tmp1 = shufflevector <4 x i8> %tmp6, <4 x i8> %tmp7, <8 x i32> <i32 0, i32 1, i32 4, i32 5, i32 4, i32 5, i32 2, i32 3>              ; <<4 x i8>> [#uses=1]
 108   %tmp9 = shufflevector <8 x i8> %tmp1, <8 x i8> undef, <4 x i32> <i32 0, i32 1, i32 4, i32 5>          ; <<4 x i8>> [#uses=1]
 109   ret <4 x i8> %tmp9
 110 }
 111
 112 ; Redundant vector splats should be removed.  Radar 8597790.
 113 define <4 x i32> @test10(<4 x i32> %tmp5) nounwind {
 114 ; CHECK: @test10
 115 ; CHECK-NEXT: shufflevector
 116 ; CHECK-NEXT: ret
 117   %tmp6 = shufflevector <4 x i32> %tmp5, <4 x i32> undef, <4 x i32> <i32 1, i32 undef, i32 undef, i32 undef>
 118   %tmp7 = shufflevector <4 x i32> %tmp6, <4 x i32> undef, <4 x i32> zeroinitializer
 119   ret <4 x i32> %tmp7
 120 }
 121
 122 ; Test fold of two shuffles where the two shufflevector inputs's op1 are
 123 ; the same
 124 define <8 x i8> @test11(<16 x i8> %tmp6) nounwind {
 125 ; CHECK: @test11
 126 ; CHECK-NEXT: shufflevector <16 x i8> %tmp6, <16 x i8> undef, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>
 127 ; CHECK-NEXT: ret
 128   %tmp1 = shufflevector <16 x i8> %tmp6, <16 x i8> undef, <4 x i32> <i32 0, i32 1, i32 2, i32 3>                ; <<4 x i8>> [#uses=1]
 129   %tmp2 = shufflevector <16 x i8> %tmp6, <16 x i8> undef, <4 x i32> <i32 4, i32 5, i32 6, i32 7>                ; <<4 x i8>> [#uses=1]
 130   %tmp3 = shufflevector <4 x i8> %tmp1, <4 x i8> %tmp2, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>              ; <<8 x i8>> [#uses=1]
 131   ret <8 x i8> %tmp3
 132 }
 133
 134 ; Test fold of two shuffles where the first shufflevector's inputs are
 135 ; the same as the second
 136 define <8 x i8> @test12(<8 x i8> %tmp6, <8 x i8> %tmp2) nounwind {
 137 ; CHECK: @test12
 138 ; CHECK-NEXT: shufflevector <8 x i8> %tmp6, <8 x i8> %tmp2, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 9, i32 8, i32 11, i32 12>
 139 ; CHECK-NEXT: ret
 140   %tmp1 = shufflevector <8 x i8> %tmp6, <8 x i8> undef, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 5, i32 4, i32 undef, i32 7>  ; <<8 x i8>> [#uses=1]
 141   %tmp3 = shufflevector <8 x i8> %tmp1, <8 x i8> %tmp2, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 9, i32 8, i32 11, i32 12>            ; <<8 x i8>> [#uses=1]
 142   ret <8 x i8> %tmp3
 143 }
 144
 145 ; Test fold of two shuffles where the first shufflevector's inputs are
 146 ; the same as the second
 147 define <8 x i8> @test12a(<8 x i8> %tmp6, <8 x i8> %tmp2) nounwind {
 148 ; CHECK: @test12a
 149 ; CHECK-NEXT: shufflevector <8 x i8> %tmp2, <8 x i8> %tmp6, <8 x i32> <i32 0, i32 3, i32 1, i32 4, i32 8, i32 9, i32 10, i32 11>
 150 ; CHECK-NEXT: ret
 151   %tmp1 = shufflevector <8 x i8> %tmp6, <8 x i8> undef, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 5, i32 4, i32 undef, i32 7>  ; <<8 x i8>> [#uses=1]
 152   %tmp3 = shufflevector <8 x i8> %tmp2, <8 x i8> %tmp1, <8 x i32> <i32 0, i32 3, i32 1, i32 4, i32 8, i32 9, i32 10, i32 11>            ; <<8 x i8>> [#uses=1]
 153   ret <8 x i8> %tmp3
 154 }
 155
 156 define <2 x i8> @test13a(i8 %x1, i8 %x2) {
 157 ; CHECK: @test13a
 158 ; CHECK-NEXT: insertelement {{.*}} undef, i8 %x1, i32 1
 159 ; CHECK-NEXT: insertelement {{.*}} i8 %x2, i32 0
 160 ; CHECK-NEXT: add {{.*}} <i8 7, i8 5>
 161 ; CHECK-NEXT: ret
 162   %A = insertelement <2 x i8> undef, i8 %x1, i32 0
 163   %B = insertelement <2 x i8> %A, i8 %x2, i32 1
 164   %C = add <2 x i8> %B, <i8 5, i8 7>
 165   %D = shufflevector <2 x i8> %C, <2 x i8> undef, <2 x i32> <i32 1, i32 0>
 166   ret <2 x i8> %D
 167 }
 168
 169 define <2 x i8> @test13b(i8 %x) {
 170 ; CHECK: @test13b
 171 ; CHECK-NEXT: insertelement <2 x i8> undef, i8 %x, i32 1
 172 ; CHECK-NEXT: ret
 173   %A = insertelement <2 x i8> undef, i8 %x, i32 0
 174   %B = shufflevector <2 x i8> %A, <2 x i8> undef, <2 x i32> <i32 undef, i32 0>
 175   ret <2 x i8> %B
 176 }
 177
 178 define <2 x i8> @test13c(i8 %x1, i8 %x2) {
 179 ; CHECK: @test13c
 180 ; CHECK-NEXT: insertelement <2 x i8> {{.*}}, i32 0
 181 ; CHECK-NEXT: insertelement <2 x i8> {{.*}}, i32 1
 182 ; CHECK-NEXT: ret
 183   %A = insertelement <4 x i8> undef, i8 %x1, i32 0
 184   %B = insertelement <4 x i8> %A, i8 %x2, i32 2
 185   %C = shufflevector <4 x i8> %B, <4 x i8> undef, <2 x i32> <i32 0, i32 2>
 186   ret <2 x i8> %C
 187 }
 188
 189 define void @test14(i16 %conv10) {
 190   %tmp = alloca <4 x i16>, align 8
 191   %vecinit6 = insertelement <4 x i16> undef, i16 23, i32 3
 192   store <4 x i16> %vecinit6, <4 x i16>* undef
 193   %tmp1 = load <4 x i16>* undef
 194   %vecinit11 = insertelement <4 x i16> undef, i16 %conv10, i32 3
 195   %div = udiv <4 x i16> %tmp1, %vecinit11
 196   store <4 x i16> %div, <4 x i16>* %tmp
 197   %tmp4 = load <4 x i16>* %tmp
 198   %tmp5 = shufflevector <4 x i16> %tmp4, <4 x i16> undef, <2 x i32> <i32 2, i32 0>
 199   %cmp = icmp ule <2 x i16> %tmp5, undef
 200   %sext = sext <2 x i1> %cmp to <2 x i16>
 201   ret void
 202 }