test/Transforms/InstCombine/insert-extract-shuffle.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt -S -instcombine %s | FileCheck %s
   3
   4 define <1 x i8> @test1(<8 x i8> %in) {
   5 ; CHECK-LABEL: @test1(
   6 ; CHECK-NEXT:    [[VEC:%.*]] = shufflevector <8 x i8> [[IN:%.*]], <8 x i8> undef, <1 x i32> <i32 5>
   7 ; CHECK-NEXT:    ret <1 x i8> [[VEC]]
   8 ;
   9   %val = extractelement <8 x i8> %in, i32 5
  10   %vec = insertelement <1 x i8> undef, i8 %val, i32 0
  11   ret <1 x i8> %vec
  12 }
  13
  14 define <4 x i16> @test2(<8 x i16> %in, <8 x i16> %in2) {
  15 ; CHECK-LABEL: @test2(
  16 ; CHECK-NEXT:    [[VEC_3:%.*]] = shufflevector <8 x i16> [[IN2:%.*]], <8 x i16> [[IN:%.*]], <4 x i32> <i32 11, i32 9, i32 0, i32 10>
  17 ; CHECK-NEXT:    ret <4 x i16> [[VEC_3]]
  18 ;
  19   %elt0 = extractelement <8 x i16> %in, i32 3
  20   %elt1 = extractelement <8 x i16> %in, i32 1
  21   %elt2 = extractelement <8 x i16> %in2, i32 0
  22   %elt3 = extractelement <8 x i16> %in, i32 2
  23
  24   %vec.0 = insertelement <4 x i16> undef, i16 %elt0, i32 0
  25   %vec.1 = insertelement <4 x i16> %vec.0, i16 %elt1, i32 1
  26   %vec.2 = insertelement <4 x i16> %vec.1, i16 %elt2, i32 2
  27   %vec.3 = insertelement <4 x i16> %vec.2, i16 %elt3, i32 3
  28
  29   ret <4 x i16> %vec.3
  30 }
  31
  32 define <2 x i64> @test_vcopyq_lane_p64(<2 x i64> %a, <1 x i64> %b) {
  33 ; CHECK-LABEL: @test_vcopyq_lane_p64(
  34 ; CHECK-NEXT:    [[TMP1:%.*]] = shufflevector <1 x i64> [[B:%.*]], <1 x i64> undef, <2 x i32> <i32 0, i32 undef>
  35 ; CHECK-NEXT:    [[RES:%.*]] = shufflevector <2 x i64> [[A:%.*]], <2 x i64> [[TMP1]], <2 x i32> <i32 0, i32 2>
  36 ; CHECK-NEXT:    ret <2 x i64> [[RES]]
  37 ;
  38   %elt = extractelement <1 x i64> %b, i32 0
  39   %res = insertelement <2 x i64> %a, i64 %elt, i32 1
  40   ret <2 x i64> %res
  41 }
  42
  43 ; PR2109: https://llvm.org/bugs/show_bug.cgi?id=2109
  44
  45 define <4 x float> @widen_extract2(<4 x float> %ins, <2 x float> %ext) {
  46 ; CHECK-LABEL: @widen_extract2(
  47 ; CHECK-NEXT:    [[TMP1:%.*]] = shufflevector <2 x float> [[EXT:%.*]], <2 x float> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
  48 ; CHECK-NEXT:    [[I2:%.*]] = shufflevector <4 x float> [[INS:%.*]], <4 x float> [[TMP1]], <4 x i32> <i32 0, i32 4, i32 2, i32 5>
  49 ; CHECK-NEXT:    ret <4 x float> [[I2]]
  50 ;
  51   %e1 = extractelement <2 x float> %ext, i32 0
  52   %e2 = extractelement <2 x float> %ext, i32 1
  53   %i1 = insertelement <4 x float> %ins, float %e1, i32 1
  54   %i2 = insertelement <4 x float> %i1, float %e2, i32 3
  55   ret <4 x float> %i2
  56 }
  57
  58 define <4 x float> @widen_extract3(<4 x float> %ins, <3 x float> %ext) {
  59 ; CHECK-LABEL: @widen_extract3(
  60 ; CHECK-NEXT:    [[TMP1:%.*]] = shufflevector <3 x float> [[EXT:%.*]], <3 x float> undef, <4 x i32> <i32 0, i32 1, i32 2, i32 undef>
  61 ; CHECK-NEXT:    [[I3:%.*]] = shufflevector <4 x float> [[INS:%.*]], <4 x float> [[TMP1]], <4 x i32> <i32 6, i32 5, i32 4, i32 3>
  62 ; CHECK-NEXT:    ret <4 x float> [[I3]]
  63 ;
  64   %e1 = extractelement <3 x float> %ext, i32 0
  65   %e2 = extractelement <3 x float> %ext, i32 1
  66   %e3 = extractelement <3 x float> %ext, i32 2
  67   %i1 = insertelement <4 x float> %ins, float %e1, i32 2
  68   %i2 = insertelement <4 x float> %i1, float %e2, i32 1
  69   %i3 = insertelement <4 x float> %i2, float %e3, i32 0
  70   ret <4 x float> %i3
  71 }
  72
  73 define <8 x float> @widen_extract4(<8 x float> %ins, <2 x float> %ext) {
  74 ; CHECK-LABEL: @widen_extract4(
  75 ; CHECK-NEXT:    [[TMP1:%.*]] = shufflevector <2 x float> [[EXT:%.*]], <2 x float> undef, <8 x i32> <i32 0, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
  76 ; CHECK-NEXT:    [[I1:%.*]] = shufflevector <8 x float> [[INS:%.*]], <8 x float> [[TMP1]], <8 x i32> <i32 0, i32 1, i32 8, i32 3, i32 4, i32 5, i32 6, i32 7>
  77 ; CHECK-NEXT:    ret <8 x float> [[I1]]
  78 ;
  79   %e1 = extractelement <2 x float> %ext, i32 0
  80   %i1 = insertelement <8 x float> %ins, float %e1, i32 2
  81   ret <8 x float> %i1
  82 }
  83
  84 ; PR26015: https://llvm.org/bugs/show_bug.cgi?id=26015
  85 ; The widening shuffle must be inserted before any uses.
  86
  87 define <8 x i16> @pr26015(<4 x i16> %t0) {
  88 ; CHECK-LABEL: @pr26015(
  89 ; CHECK-NEXT:    [[TMP1:%.*]] = shufflevector <4 x i16> [[T0:%.*]], <4 x i16> undef, <8 x i32> <i32 undef, i32 undef, i32 2, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
  90 ; CHECK-NEXT:    [[T5:%.*]] = shufflevector <8 x i16> <i16 0, i16 0, i16 0, i16 undef, i16 0, i16 0, i16 0, i16 undef>, <8 x i16> [[TMP1]], <8 x i32> <i32 0, i32 1, i32 2, i32 10, i32 4, i32 5, i32 6, i32 11>
  91 ; CHECK-NEXT:    ret <8 x i16> [[T5]]
  92 ;
  93   %t1 = extractelement <4 x i16> %t0, i32 2
  94   %t2 = insertelement <8 x i16> zeroinitializer, i16 %t1, i32 3
  95   %t3 = insertelement <8 x i16> %t2, i16 0, i32 6
  96   %t4 = extractelement <4 x i16> %t0, i32 3
  97   %t5 = insertelement <8 x i16> %t3, i16 %t4, i32 7
  98   ret <8 x i16> %t5
  99 }
 100
 101 ; PR25999: https://llvm.org/bugs/show_bug.cgi?id=25999
 102 ; TODO: The widening shuffle could be inserted at the start of the function to allow the first extract to use it.
 103
 104 define <8 x i16> @pr25999(<4 x i16> %t0, i1 %b) {
 105 ; CHECK-LABEL: @pr25999(
 106 ; CHECK-NEXT:    [[T1:%.*]] = extractelement <4 x i16> [[T0:%.*]], i32 2
 107 ; CHECK-NEXT:    br i1 [[B:%.*]], label [[IF:%.*]], label [[END:%.*]]
 108 ; CHECK:       if:
 109 ; CHECK-NEXT:    [[TMP1:%.*]] = shufflevector <4 x i16> [[T0]], <4 x i16> undef, <8 x i32> <i32 undef, i32 undef, i32 undef, i32 3, i32 undef, i32 undef, i32 undef, i32 undef>
 110 ; CHECK-NEXT:    [[T3:%.*]] = insertelement <8 x i16> <i16 0, i16 0, i16 0, i16 undef, i16 0, i16 0, i16 0, i16 undef>, i16 [[T1]], i32 3
 111 ; CHECK-NEXT:    [[T5:%.*]] = shufflevector <8 x i16> [[T3]], <8 x i16> [[TMP1]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 11>
 112 ; CHECK-NEXT:    ret <8 x i16> [[T5]]
 113 ; CHECK:       end:
 114 ; CHECK-NEXT:    [[A1:%.*]] = add i16 [[T1]], 4
 115 ; CHECK-NEXT:    [[T6:%.*]] = insertelement <8 x i16> <i16 undef, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0, i16 0>, i16 [[A1]], i32 0
 116 ; CHECK-NEXT:    ret <8 x i16> [[T6]]
 117 ;
 118
 119   %t1 = extractelement <4 x i16> %t0, i32 2
 120   br i1 %b, label %if, label %end
 121
 122 if:
 123   %t2 = insertelement <8 x i16> zeroinitializer, i16 %t1, i32 3
 124   %t3 = insertelement <8 x i16> %t2, i16 0, i32 6
 125   %t4 = extractelement <4 x i16> %t0, i32 3
 126   %t5 = insertelement <8 x i16> %t3, i16 %t4, i32 7
 127   ret <8 x i16> %t5
 128
 129 end:
 130   %a1 = add i16 %t1, 4
 131   %t6 = insertelement <8 x i16> zeroinitializer, i16 %a1, i32 0
 132   ret <8 x i16> %t6
 133 }
 134
 135 ; The widening shuffle must be inserted at a valid point (after the PHIs).
 136
 137 define <4 x double> @pr25999_phis1(i1 %c, <2 x double> %a, <4 x double> %b) {
 138 ; CHECK-LABEL: @pr25999_phis1(
 139 ; CHECK-NEXT:  bb1:
 140 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB2:%.*]], label [[BB3:%.*]]
 141 ; CHECK:       bb2:
 142 ; CHECK-NEXT:    [[R:%.*]] = call <2 x double> @dummy(<2 x double> [[A:%.*]])
 143 ; CHECK-NEXT:    br label [[BB3]]
 144 ; CHECK:       bb3:
 145 ; CHECK-NEXT:    [[TMP1:%.*]] = phi <2 x double> [ [[A]], [[BB1:%.*]] ], [ [[R]], [[BB2]] ]
 146 ; CHECK-NEXT:    [[TMP2:%.*]] = phi <4 x double> [ [[B:%.*]], [[BB1]] ], [ zeroinitializer, [[BB2]] ]
 147 ; CHECK-NEXT:    [[TMP0:%.*]] = shufflevector <2 x double> [[TMP1]], <2 x double> undef, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
 148 ; CHECK-NEXT:    [[TMP4:%.*]] = shufflevector <4 x double> [[TMP2]], <4 x double> [[TMP0]], <4 x i32> <i32 0, i32 1, i32 4, i32 3>
 149 ; CHECK-NEXT:    ret <4 x double> [[TMP4]]
 150 ;
 151 bb1:
 152   br i1 %c, label %bb2, label %bb3
 153
 154 bb2:
 155   %r = call <2 x double> @dummy(<2 x double> %a)
 156   br label %bb3
 157
 158 bb3:
 159   %tmp1 = phi <2 x double> [ %a, %bb1 ], [ %r, %bb2 ]
 160   %tmp2 = phi <4 x double> [ %b, %bb1 ], [ zeroinitializer, %bb2 ]
 161   %tmp3 = extractelement <2 x double> %tmp1, i32 0
 162   %tmp4 = insertelement <4 x double> %tmp2, double %tmp3, i32 2
 163   ret <4 x double> %tmp4
 164 }
 165
 166 declare <2 x double> @dummy(<2 x double>)
 167
 168 define <4 x double> @pr25999_phis2(i1 %c, <2 x double> %a, <4 x double> %b) {
 169 ; CHECK-LABEL: @pr25999_phis2(
 170 ; CHECK-NEXT:  bb1:
 171 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[BB2:%.*]], label [[BB3:%.*]]
 172 ; CHECK:       bb2:
 173 ; CHECK-NEXT:    [[R:%.*]] = call <2 x double> @dummy(<2 x double> [[A:%.*]])
 174 ; CHECK-NEXT:    br label [[BB3]]
 175 ; CHECK:       bb3:
 176 ; CHECK-NEXT:    [[TMP1:%.*]] = phi <2 x double> [ [[A]], [[BB1:%.*]] ], [ [[R]], [[BB2]] ]
 177 ; CHECK-NEXT:    [[TMP2:%.*]] = phi <4 x double> [ [[B:%.*]], [[BB1]] ], [ zeroinitializer, [[BB2]] ]
 178 ; CHECK-NEXT:    [[D:%.*]] = fadd <2 x double> [[TMP1]], [[TMP1]]
 179 ; CHECK-NEXT:    [[TMP0:%.*]] = shufflevector <2 x double> [[D]], <2 x double> undef, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
 180 ; CHECK-NEXT:    [[TMP4:%.*]] = shufflevector <4 x double> [[TMP2]], <4 x double> [[TMP0]], <4 x i32> <i32 0, i32 1, i32 4, i32 3>
 181 ; CHECK-NEXT:    ret <4 x double> [[TMP4]]
 182 ;
 183 bb1:
 184   br i1 %c, label %bb2, label %bb3
 185
 186 bb2:
 187   %r = call <2 x double> @dummy(<2 x double> %a)
 188   br label %bb3
 189
 190 bb3:
 191   %tmp1 = phi <2 x double> [ %a, %bb1 ], [ %r, %bb2 ]
 192   %tmp2 = phi <4 x double> [ %b, %bb1 ], [ zeroinitializer, %bb2 ]
 193   %d = fadd <2 x double> %tmp1, %tmp1
 194   %tmp3 = extractelement <2 x double> %d, i32 0
 195   %tmp4 = insertelement <4 x double> %tmp2, double %tmp3, i32 2
 196   ret <4 x double> %tmp4
 197 }
 198
 199 ; PR26354: https://llvm.org/bugs/show_bug.cgi?id=26354
 200 ; Don't create a shufflevector if we know that we're not going to replace the insertelement.
 201
 202 define double @pr26354(<2 x double>* %tmp, i1 %B) {
 203 ; CHECK-LABEL: @pr26354(
 204 ; CHECK-NEXT:  entry:
 205 ; CHECK-NEXT:    [[LD:%.*]] = load <2 x double>, <2 x double>* [[TMP:%.*]], align 16
 206 ; CHECK-NEXT:    [[E1:%.*]] = extractelement <2 x double> [[LD]], i32 0
 207 ; CHECK-NEXT:    br i1 [[B:%.*]], label [[IF:%.*]], label [[END:%.*]]
 208 ; CHECK:       if:
 209 ; CHECK-NEXT:    [[E2:%.*]] = extractelement <2 x double> [[LD]], i32 1
 210 ; CHECK-NEXT:    [[I1:%.*]] = insertelement <4 x double> <double 0.000000e+00, double 0.000000e+00, double 0.000000e+00, double undef>, double [[E2]], i32 3
 211 ; CHECK-NEXT:    br label [[END]]
 212 ; CHECK:       end:
 213 ; CHECK-NEXT:    [[PH:%.*]] = phi <4 x double> [ undef, [[ENTRY:%.*]] ], [ [[I1]], [[IF]] ]
 214 ; CHECK-NEXT:    [[E3:%.*]] = extractelement <4 x double> [[PH]], i32 1
 215 ; CHECK-NEXT:    [[MU:%.*]] = fmul double [[E1]], [[E3]]
 216 ; CHECK-NEXT:    ret double [[MU]]
 217 ;
 218
 219 entry:
 220   %ld = load <2 x double>, <2 x double>* %tmp
 221   %e1 = extractelement <2 x double> %ld, i32 0
 222   %e2 = extractelement <2 x double> %ld, i32 1
 223   br i1 %B, label %if, label %end
 224
 225 if:
 226   %i1 = insertelement <4 x double> zeroinitializer, double %e2, i32 3
 227   br label %end
 228
 229 end:
 230   %ph = phi <4 x double> [ undef, %entry ], [ %i1, %if ]
 231   %e3 = extractelement <4 x double> %ph, i32 1
 232   %mu = fmul double %e1, %e3
 233   ret double %mu
 234 }
 235
 236 ; https://llvm.org/bugs/show_bug.cgi?id=30923
 237 ; Delete the widening shuffle if we're not going to reduce the extract/insert to a shuffle.
 238
 239 define <4 x float> @PR30923(<2 x float> %x) {
 240 ; CHECK-LABEL: @PR30923(
 241 ; CHECK-NEXT:  bb1:
 242 ; CHECK-NEXT:    [[EXT1:%.*]] = extractelement <2 x float> [[X:%.*]], i32 1
 243 ; CHECK-NEXT:    store float [[EXT1]], float* undef, align 4
 244 ; CHECK-NEXT:    br label [[BB2:%.*]]
 245 ; CHECK:       bb2:
 246 ; CHECK-NEXT:    [[EXT2:%.*]] = extractelement <2 x float> [[X]], i32 0
 247 ; CHECK-NEXT:    [[INS1:%.*]] = insertelement <4 x float> <float 0.000000e+00, float 0.000000e+00, float undef, float undef>, float [[EXT2]], i32 2
 248 ; CHECK-NEXT:    [[INS2:%.*]] = insertelement <4 x float> [[INS1]], float [[EXT1]], i32 3
 249 ; CHECK-NEXT:    ret <4 x float> [[INS2]]
 250 ;
 251 bb1:
 252   %ext1 = extractelement <2 x float> %x, i32 1
 253   store float %ext1, float* undef, align 4
 254   br label %bb2
 255
 256 bb2:
 257   %widen = shufflevector <2 x float> %x, <2 x float> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
 258   %ext2 = extractelement <4 x float> %widen, i32 0
 259   %ins1 = insertelement <4 x float> <float 0.0, float 0.0, float undef, float undef>, float %ext2, i32 2
 260   %ins2 = insertelement <4 x float> %ins1, float %ext1, i32 3
 261   ret <4 x float> %ins2
 262 }
 263
 264 ; Don't insert extractelements from the wider vector before the def of the index operand.
 265
 266 define <4 x i32> @extractelt_insertion(<2 x i32> %x, i32 %y) {
 267 ; CHECK-LABEL: @extractelt_insertion(
 268 ; CHECK-NEXT:  entry:
 269 ; CHECK-NEXT:    [[TMP0:%.*]] = shufflevector <2 x i32> [[X:%.*]], <2 x i32> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
 270 ; CHECK-NEXT:    [[B:%.*]] = shufflevector <4 x i32> <i32 0, i32 0, i32 0, i32 undef>, <4 x i32> [[TMP0]], <4 x i32> <i32 0, i32 1, i32 2, i32 5>
 271 ; CHECK-NEXT:    [[C:%.*]] = add i32 [[Y:%.*]], 3
 272 ; CHECK-NEXT:    [[TMP1:%.*]] = extractelement <4 x i32> [[TMP0]], i32 [[C]]
 273 ; CHECK-NEXT:    [[E:%.*]] = icmp eq i32 [[TMP1]], 0
 274 ; CHECK-NEXT:    [[RET:%.*]] = select i1 [[E]], <4 x i32> [[B]], <4 x i32> zeroinitializer
 275 ; CHECK-NEXT:    ret <4 x i32> [[RET]]
 276 ;
 277 entry:
 278   %a = extractelement <2 x i32> %x, i32 1
 279   %b = insertelement <4 x i32> zeroinitializer, i32 %a, i64 3
 280   %c = add i32 %y, 3
 281   %d = extractelement <2 x i32> %x, i32 %c
 282   %e = icmp eq i32 %d, 0
 283   %ret = select i1 %e, <4 x i32> %b, <4 x i32> zeroinitializer
 284   ret <4 x i32> %ret
 285 }
 286
 287 ; PR34724: https://bugs.llvm.org/show_bug.cgi?id=34724
 288
 289 define <4 x float> @collectShuffleElts(<2 x float> %x, float %y) {
 290 ; CHECK-LABEL: @collectShuffleElts(
 291 ; CHECK-NEXT:    [[X0:%.*]] = extractelement <2 x float> [[X:%.*]], i32 0
 292 ; CHECK-NEXT:    [[X1:%.*]] = extractelement <2 x float> [[X]], i32 1
 293 ; CHECK-NEXT:    [[V1:%.*]] = insertelement <4 x float> undef, float [[X0]], i32 1
 294 ; CHECK-NEXT:    [[V2:%.*]] = insertelement <4 x float> [[V1]], float [[X1]], i32 2
 295 ; CHECK-NEXT:    [[V3:%.*]] = insertelement <4 x float> [[V2]], float [[Y:%.*]], i32 3
 296 ; CHECK-NEXT:    ret <4 x float> [[V3]]
 297 ;
 298   %x0 = extractelement <2 x float> %x, i32 0
 299   %x1 = extractelement <2 x float> %x, i32 1
 300   %v1 = insertelement <4 x float> undef, float %x0, i32 1
 301   %v2 = insertelement <4 x float> %v1, float %x1, i32 2
 302   %v3 = insertelement <4 x float> %v2, float %y, i32 3
 303   ret <4 x float> %v3
 304 }
 305
 306 ; Simplest case - insert scalar into undef, then shuffle that value in place into another vector.
 307
 308 define <4 x float> @insert_shuffle(float %x, <4 x float> %y) {
 309 ; CHECK-LABEL: @insert_shuffle(
 310 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x float> [[Y:%.*]], float [[X:%.*]], i32 0
 311 ; CHECK-NEXT:    ret <4 x float> [[R]]
 312 ;
 313   %xv = insertelement <4 x float> undef, float %x, i32 0
 314   %r = shufflevector <4 x float> %xv, <4 x float> %y, <4 x i32> <i32 0, i32 5, i32 6, i32 7>
 315   ret <4 x float> %r
 316 }
 317
 318 ; Insert scalar into some element of a dummy vector, then move it to a different element in another vector.
 319
 320 define <4 x float> @insert_shuffle_translate(float %x, <4 x float> %y) {
 321 ; CHECK-LABEL: @insert_shuffle_translate(
 322 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x float> [[Y:%.*]], float [[X:%.*]], i32 1
 323 ; CHECK-NEXT:    ret <4 x float> [[R]]
 324 ;
 325   %xv = insertelement <4 x float> undef, float %x, i32 0
 326   %r = shufflevector <4 x float> %xv, <4 x float> %y, <4 x i32> <i32 4, i32 0, i32 6, i32 7>
 327   ret <4 x float> %r
 328 }
 329
 330 ; The vector operand of the insert is irrelevant.
 331
 332 define <4 x float> @insert_not_undef_shuffle_translate(float %x, <4 x float> %y, <4 x float> %q) {
 333 ; CHECK-LABEL: @insert_not_undef_shuffle_translate(
 334 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x float> [[Y:%.*]], float [[X:%.*]], i32 2
 335 ; CHECK-NEXT:    ret <4 x float> [[R]]
 336 ;
 337   %xv = insertelement <4 x float> %q, float %x, i32 3
 338   %r = shufflevector <4 x float> %xv, <4 x float> %y, <4 x i32> <i32 4, i32 5, i32 3, i32 7>
 339   ret <4 x float> %r
 340 }
 341
 342 ; The insert may be the 2nd operand of the shuffle. The shuffle mask can include undef elements.
 343
 344 define <4 x float> @insert_not_undef_shuffle_translate_commute(float %x, <4 x float> %y, <4 x float> %q) {
 345 ; CHECK-LABEL: @insert_not_undef_shuffle_translate_commute(
 346 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x float> [[Y:%.*]], float [[X:%.*]], i32 1
 347 ; CHECK-NEXT:    ret <4 x float> [[R]]
 348 ;
 349   %xv = insertelement <4 x float> %q, float %x, i32 2
 350   %r = shufflevector <4 x float> %y, <4 x float> %xv, <4 x i32> <i32 0, i32 6, i32 2, i32 undef>
 351   ret <4 x float> %r
 352 }
 353
 354 ; Both shuffle operands may be inserts - choose the correct side.
 355
 356 define <4 x float> @insert_insert_shuffle_translate(float %x1, float %x2, <4 x float> %q) {
 357 ; CHECK-LABEL: @insert_insert_shuffle_translate(
 358 ; CHECK-NEXT:    [[XV2:%.*]] = insertelement <4 x float> [[Q:%.*]], float [[X2:%.*]], i32 2
 359 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x float> [[XV2]], float [[X1:%.*]], i32 1
 360 ; CHECK-NEXT:    ret <4 x float> [[R]]
 361 ;
 362   %xv1 = insertelement <4 x float> %q, float %x1, i32 0
 363   %xv2 = insertelement <4 x float> %q, float %x2, i32 2
 364   %r = shufflevector <4 x float> %xv1, <4 x float> %xv2, <4 x i32> <i32 4, i32 0, i32 6, i32 7>
 365   ret <4 x float> %r
 366 }
 367
 368 ; Both shuffle operands may be inserts - choose the correct side.
 369
 370 define <4 x float> @insert_insert_shuffle_translate_commute(float %x1, float %x2, <4 x float> %q) {
 371 ; CHECK-LABEL: @insert_insert_shuffle_translate_commute(
 372 ; CHECK-NEXT:    [[XV1:%.*]] = insertelement <4 x float> [[Q:%.*]], float [[X1:%.*]], i32 0
 373 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x float> [[XV1]], float [[X2:%.*]], i32 1
 374 ; CHECK-NEXT:    ret <4 x float> [[R]]
 375 ;
 376   %xv1 = insertelement <4 x float> %q, float %x1, i32 0
 377   %xv2 = insertelement <4 x float> %q, float %x2, i32 2
 378   %r = shufflevector <4 x float> %xv1, <4 x float> %xv2, <4 x i32> <i32 0, i32 6, i32 2, i32 3>
 379   ret <4 x float> %r
 380 }
 381
 382 ; Negative test - this only works if the shuffle is choosing exactly 1 element from 1 of the inputs.
 383 ; TODO: But this could be a special-case because we're inserting into the same base vector.
 384
 385 define <4 x float> @insert_insert_shuffle_translate_wrong_mask(float %x1, float %x2, <4 x float> %q) {
 386 ; CHECK-LABEL: @insert_insert_shuffle_translate_wrong_mask(
 387 ; CHECK-NEXT:    [[XV1:%.*]] = insertelement <4 x float> [[Q:%.*]], float [[X1:%.*]], i32 0
 388 ; CHECK-NEXT:    [[XV2:%.*]] = insertelement <4 x float> [[Q]], float [[X2:%.*]], i32 2
 389 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[XV1]], <4 x float> [[XV2]], <4 x i32> <i32 0, i32 6, i32 2, i32 7>
 390 ; CHECK-NEXT:    ret <4 x float> [[R]]
 391 ;
 392   %xv1 = insertelement <4 x float> %q, float %x1, i32 0
 393   %xv2 = insertelement <4 x float> %q, float %x2, i32 2
 394   %r = shufflevector <4 x float> %xv1, <4 x float> %xv2, <4 x i32> <i32 0, i32 6, i32 2, i32 7>
 395   ret <4 x float> %r
 396 }
 397
 398 ; The insert may have other uses.
 399
 400 declare void @use(<4 x float>)
 401
 402 define <4 x float> @insert_not_undef_shuffle_translate_commute_uses(float %x, <4 x float> %y, <4 x float> %q) {
 403 ; CHECK-LABEL: @insert_not_undef_shuffle_translate_commute_uses(
 404 ; CHECK-NEXT:    [[XV:%.*]] = insertelement <4 x float> [[Q:%.*]], float [[X:%.*]], i32 2
 405 ; CHECK-NEXT:    call void @use(<4 x float> [[XV]])
 406 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x float> [[Y:%.*]], float [[X]], i32 0
 407 ; CHECK-NEXT:    ret <4 x float> [[R]]
 408 ;
 409   %xv = insertelement <4 x float> %q, float %x, i32 2
 410   call void @use(<4 x float> %xv)
 411   %r = shufflevector <4 x float> %y, <4 x float> %xv, <4 x i32> <i32 6, i32 undef, i32 2, i32 3>
 412   ret <4 x float> %r
 413 }
 414
 415 ; Negative test - size-changing shuffle.
 416
 417 define <5 x float> @insert_not_undef_shuffle_translate_commute_lengthen(float %x, <4 x float> %y, <4 x float> %q) {
 418 ; CHECK-LABEL: @insert_not_undef_shuffle_translate_commute_lengthen(
 419 ; CHECK-NEXT:    [[XV:%.*]] = insertelement <4 x float> undef, float [[X:%.*]], i32 2
 420 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[Y:%.*]], <4 x float> [[XV]], <5 x i32> <i32 0, i32 6, i32 2, i32 undef, i32 undef>
 421 ; CHECK-NEXT:    ret <5 x float> [[R]]
 422 ;
 423   %xv = insertelement <4 x float> %q, float %x, i32 2
 424   %r = shufflevector <4 x float> %y, <4 x float> %xv, <5 x i32> <i32 0, i32 6, i32 2, i32 undef, i32 undef>
 425   ret <5 x float> %r
 426 }
 427
 428 define <4 x float> @insert_nonzero_index_splat(float %x) {
 429 ; CHECK-LABEL: @insert_nonzero_index_splat(
 430 ; CHECK-NEXT:    [[TMP1:%.*]] = insertelement <4 x float> undef, float [[X:%.*]], i32 0
 431 ; CHECK-NEXT:    [[SPLAT:%.*]] = shufflevector <4 x float> [[TMP1]], <4 x float> undef, <4 x i32> <i32 undef, i32 0, i32 0, i32 undef>
 432 ; CHECK-NEXT:    ret <4 x float> [[SPLAT]]
 433 ;
 434   %xv = insertelement <4 x float> undef, float %x, i32 2
 435   %splat = shufflevector <4 x float> %xv, <4 x float> undef, <4 x i32> <i32 undef, i32 2, i32 2, i32 undef>
 436   ret <4 x float> %splat
 437 }
 438
 439 define <3 x double> @insert_nonzero_index_splat_narrow(double %x) {
 440 ; CHECK-LABEL: @insert_nonzero_index_splat_narrow(
 441 ; CHECK-NEXT:    [[TMP1:%.*]] = insertelement <3 x double> undef, double [[X:%.*]], i32 0
 442 ; CHECK-NEXT:    [[SPLAT:%.*]] = shufflevector <3 x double> [[TMP1]], <3 x double> undef, <3 x i32> <i32 0, i32 undef, i32 0>
 443 ; CHECK-NEXT:    ret <3 x double> [[SPLAT]]
 444 ;
 445   %xv = insertelement <4 x double> undef, double %x, i32 3
 446   %splat = shufflevector <4 x double> %xv, <4 x double> undef, <3 x i32> <i32 3, i32 undef, i32 3>
 447   ret <3 x double> %splat
 448 }
 449
 450 define <5 x i7> @insert_nonzero_index_splat_widen(i7 %x) {
 451 ; CHECK-LABEL: @insert_nonzero_index_splat_widen(
 452 ; CHECK-NEXT:    [[TMP1:%.*]] = insertelement <5 x i7> undef, i7 [[X:%.*]], i32 0
 453 ; CHECK-NEXT:    [[SPLAT:%.*]] = shufflevector <5 x i7> [[TMP1]], <5 x i7> undef, <5 x i32> <i32 undef, i32 0, i32 0, i32 undef, i32 0>
 454 ; CHECK-NEXT:    ret <5 x i7> [[SPLAT]]
 455 ;
 456   %xv = insertelement <4 x i7> undef, i7 %x, i32 1
 457   %splat = shufflevector <4 x i7> %xv, <4 x i7> undef, <5 x i32> <i32 undef, i32 1, i32 1, i32 undef, i32 1>
 458   ret <5 x i7> %splat
 459 }
 460
 461 ; Negative test - don't increase instruction count
 462
 463 define <4 x float> @insert_nonzero_index_splat_extra_use(float %x) {
 464 ; CHECK-LABEL: @insert_nonzero_index_splat_extra_use(
 465 ; CHECK-NEXT:    [[XV:%.*]] = insertelement <4 x float> undef, float [[X:%.*]], i32 2
 466 ; CHECK-NEXT:    call void @use(<4 x float> [[XV]])
 467 ; CHECK-NEXT:    [[SPLAT:%.*]] = shufflevector <4 x float> [[XV]], <4 x float> undef, <4 x i32> <i32 undef, i32 2, i32 2, i32 undef>
 468 ; CHECK-NEXT:    ret <4 x float> [[SPLAT]]
 469 ;
 470   %xv = insertelement <4 x float> undef, float %x, i32 2
 471   call void @use(<4 x float> %xv)
 472   %splat = shufflevector <4 x float> %xv, <4 x float> undef, <4 x i32> <i32 undef, i32 2, i32 2, i32 undef>
 473   ret <4 x float> %splat
 474 }
 475
 476 ; Negative test - non-undef base vector
 477
 478 define <4 x float> @insert_nonzero_index_splat_wrong_base(float %x, <4 x float> %y) {
 479 ; CHECK-LABEL: @insert_nonzero_index_splat_wrong_base(
 480 ; CHECK-NEXT:    [[XV:%.*]] = insertelement <4 x float> [[Y:%.*]], float [[X:%.*]], i32 2
 481 ; CHECK-NEXT:    [[SPLAT:%.*]] = shufflevector <4 x float> [[XV]], <4 x float> undef, <4 x i32> <i32 undef, i32 2, i32 3, i32 undef>
 482 ; CHECK-NEXT:    ret <4 x float> [[SPLAT]]
 483 ;
 484   %xv = insertelement <4 x float> %y, float %x, i32 2
 485   %splat = shufflevector <4 x float> %xv, <4 x float> undef, <4 x i32> <i32 undef, i32 2, i32 3, i32 undef>
 486   ret <4 x float> %splat
 487 }
 488
 489 ; Negative test - non-constant insert index
 490
 491 define <4 x float> @insert_nonzero_index_splat_wrong_index(float %x, i32 %index) {
 492 ; CHECK-LABEL: @insert_nonzero_index_splat_wrong_index(
 493 ; CHECK-NEXT:    [[XV:%.*]] = insertelement <4 x float> undef, float [[X:%.*]], i32 [[INDEX:%.*]]
 494 ; CHECK-NEXT:    [[SPLAT:%.*]] = shufflevector <4 x float> [[XV]], <4 x float> undef, <4 x i32> <i32 undef, i32 1, i32 1, i32 undef>
 495 ; CHECK-NEXT:    ret <4 x float> [[SPLAT]]
 496 ;
 497   %xv = insertelement <4 x float> undef, float %x, i32 %index
 498   %splat = shufflevector <4 x float> %xv, <4 x float> undef, <4 x i32> <i32 undef, i32 1, i32 1, i32 undef>
 499   ret <4 x float> %splat
 500 }
 501
 502 define <4 x float> @insert_in_splat(float %x) {
 503 ; CHECK-LABEL: @insert_in_splat(
 504 ; CHECK-NEXT:    [[XV:%.*]] = insertelement <4 x float> undef, float [[X:%.*]], i32 0
 505 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[XV]], <4 x float> undef, <4 x i32> <i32 undef, i32 0, i32 0, i32 0>
 506 ; CHECK-NEXT:    ret <4 x float> [[R]]
 507 ;
 508   %xv = insertelement <4 x float> undef, float %x, i32 0
 509   %splat = shufflevector <4 x float> %xv, <4 x float> undef, <4 x i32> <i32 undef, i32 0, i32 0, i32 undef>
 510   %r = insertelement <4 x float> %splat, float %x, i32 3
 511   ret <4 x float> %r
 512 }
 513
 514 define <4 x float> @insert_in_splat_extra_uses(float %x) {
 515 ; CHECK-LABEL: @insert_in_splat_extra_uses(
 516 ; CHECK-NEXT:    [[XV:%.*]] = insertelement <4 x float> undef, float [[X:%.*]], i32 0
 517 ; CHECK-NEXT:    call void @use(<4 x float> [[XV]])
 518 ; CHECK-NEXT:    [[SPLAT:%.*]] = shufflevector <4 x float> [[XV]], <4 x float> undef, <4 x i32> <i32 undef, i32 0, i32 0, i32 undef>
 519 ; CHECK-NEXT:    call void @use(<4 x float> [[SPLAT]])
 520 ; CHECK-NEXT:    [[R:%.*]] = shufflevector <4 x float> [[XV]], <4 x float> undef, <4 x i32> <i32 undef, i32 0, i32 0, i32 0>
 521 ; CHECK-NEXT:    ret <4 x float> [[R]]
 522 ;
 523   %xv = insertelement <4 x float> undef, float %x, i32 0
 524   call void @use(<4 x float> %xv)
 525   %splat = shufflevector <4 x float> %xv, <4 x float> undef, <4 x i32> <i32 undef, i32 0, i32 0, i32 undef>
 526   call void @use(<4 x float> %splat)
 527   %r = insertelement <4 x float> %splat, float %x, i32 3
 528   ret <4 x float> %r
 529 }
 530
 531 ; Negative test - not a constant index insert
 532
 533 define <4 x float> @insert_in_splat_variable_index(float %x, i32 %y) {
 534 ; CHECK-LABEL: @insert_in_splat_variable_index(
 535 ; CHECK-NEXT:    [[XV:%.*]] = insertelement <4 x float> undef, float [[X:%.*]], i32 0
 536 ; CHECK-NEXT:    [[SPLAT:%.*]] = shufflevector <4 x float> [[XV]], <4 x float> undef, <4 x i32> <i32 undef, i32 0, i32 0, i32 undef>
 537 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x float> [[SPLAT]], float [[X]], i32 [[Y:%.*]]
 538 ; CHECK-NEXT:    ret <4 x float> [[R]]
 539 ;
 540   %xv = insertelement <4 x float> undef, float %x, i32 0
 541   %splat = shufflevector <4 x float> %xv, <4 x float> undef, <4 x i32> <i32 undef, i32 0, i32 0, i32 undef>
 542   %r = insertelement <4 x float> %splat, float %x, i32 %y
 543   ret <4 x float> %r
 544 }
 545
 546 ; Negative test - not a splat shuffle
 547
 548 define <4 x float> @insert_in_nonsplat(float %x, <4 x float> %y) {
 549 ; CHECK-LABEL: @insert_in_nonsplat(
 550 ; CHECK-NEXT:    [[XV:%.*]] = insertelement <4 x float> undef, float [[X:%.*]], i32 0
 551 ; CHECK-NEXT:    [[SPLAT:%.*]] = shufflevector <4 x float> [[XV]], <4 x float> [[Y:%.*]], <4 x i32> <i32 undef, i32 0, i32 4, i32 undef>
 552 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x float> [[SPLAT]], float [[X]], i32 3
 553 ; CHECK-NEXT:    ret <4 x float> [[R]]
 554 ;
 555   %xv = insertelement <4 x float> undef, float %x, i32 0
 556   %splat = shufflevector <4 x float> %xv, <4 x float> %y, <4 x i32> <i32 undef, i32 0, i32 4, i32 undef>
 557   %r = insertelement <4 x float> %splat, float %x, i32 3
 558   ret <4 x float> %r
 559 }
 560
 561 ; Negative test - not a splat shuffle
 562
 563 define <4 x float> @insert_in_nonsplat2(float %x, <4 x float> %y) {
 564 ; CHECK-LABEL: @insert_in_nonsplat2(
 565 ; CHECK-NEXT:    [[XV:%.*]] = insertelement <4 x float> [[Y:%.*]], float [[X:%.*]], i32 0
 566 ; CHECK-NEXT:    [[SPLAT:%.*]] = shufflevector <4 x float> [[XV]], <4 x float> undef, <4 x i32> <i32 undef, i32 0, i32 1, i32 undef>
 567 ; CHECK-NEXT:    [[R:%.*]] = insertelement <4 x float> [[SPLAT]], float [[X]], i32 3
 568 ; CHECK-NEXT:    ret <4 x float> [[R]]
 569 ;
 570   %xv = insertelement <4 x float> %y, float %x, i32 0
 571   %splat = shufflevector <4 x float> %xv, <4 x float> undef, <4 x i32> <i32 undef, i32 0, i32 1, i32 undef>
 572   %r = insertelement <4 x float> %splat, float %x, i32 3
 573   ret <4 x float> %r
 574 }
 575
 576 define <4 x i8> @shuf_identity_padding(<2 x i8> %x, i8 %y) {
 577 ; CHECK-LABEL: @shuf_identity_padding(
 578 ; CHECK-NEXT:    [[V1:%.*]] = shufflevector <2 x i8> [[X:%.*]], <2 x i8> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
 579 ; CHECK-NEXT:    [[V2:%.*]] = insertelement <4 x i8> [[V1]], i8 [[Y:%.*]], i32 2
 580 ; CHECK-NEXT:    ret <4 x i8> [[V2]]
 581 ;
 582   %v0 = shufflevector <2 x i8> %x, <2 x i8> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
 583   %x1 = extractelement <2 x i8> %x, i32 1
 584   %v1 = insertelement <4 x i8> %v0, i8 %x1, i32 1
 585   %v2 = insertelement <4 x i8> %v1, i8 %y, i32 2
 586   ret <4 x i8> %v2
 587 }
 588
 589 define <3 x i8> @shuf_identity_extract(<4 x i8> %x, i8 %y) {
 590 ; CHECK-LABEL: @shuf_identity_extract(
 591 ; CHECK-NEXT:    [[V1:%.*]] = shufflevector <4 x i8> [[X:%.*]], <4 x i8> undef, <3 x i32> <i32 0, i32 1, i32 undef>
 592 ; CHECK-NEXT:    [[V2:%.*]] = insertelement <3 x i8> [[V1]], i8 [[Y:%.*]], i32 2
 593 ; CHECK-NEXT:    ret <3 x i8> [[V2]]
 594 ;
 595   %v0 = shufflevector <4 x i8> %x, <4 x i8> undef, <3 x i32> <i32 0, i32 undef, i32 undef>
 596   %x1 = extractelement <4 x i8> %x, i32 1
 597   %v1 = insertelement <3 x i8> %v0, i8 %x1, i32 1
 598   %v2 = insertelement <3 x i8> %v1, i8 %y, i32 2
 599   ret <3 x i8> %v2
 600 }
 601
 602 define <4 x float> @shuf_identity_extract_extra_use(<6 x float> %x, float %y) {
 603 ; CHECK-LABEL: @shuf_identity_extract_extra_use(
 604 ; CHECK-NEXT:    [[V0:%.*]] = shufflevector <6 x float> [[X:%.*]], <6 x float> undef, <4 x i32> <i32 0, i32 undef, i32 undef, i32 3>
 605 ; CHECK-NEXT:    call void @use(<4 x float> [[V0]])
 606 ; CHECK-NEXT:    [[V1:%.*]] = shufflevector <6 x float> [[X]], <6 x float> undef, <4 x i32> <i32 0, i32 undef, i32 2, i32 3>
 607 ; CHECK-NEXT:    [[V2:%.*]] = insertelement <4 x float> [[V1]], float [[Y:%.*]], i32 1
 608 ; CHECK-NEXT:    ret <4 x float> [[V2]]
 609 ;
 610   %v0 = shufflevector <6 x float> %x, <6 x float> undef, <4 x i32> <i32 0, i32 undef, i32 undef, i32 3>
 611   call void @use(<4 x float> %v0)
 612   %x1 = extractelement <6 x float> %x, i32 2
 613   %v1 = insertelement <4 x float> %v0, float %x1, i32 2
 614   %v2 = insertelement <4 x float> %v1, float %y, i32 1
 615   ret <4 x float> %v2
 616 }
 617
 618 ; Negative test - can't map variable index to shuffle mask.
 619
 620 define <4 x i8> @shuf_identity_padding_variable_index(<2 x i8> %x, i8 %y, i32 %index) {
 621 ; CHECK-LABEL: @shuf_identity_padding_variable_index(
 622 ; CHECK-NEXT:    [[V0:%.*]] = shufflevector <2 x i8> [[X:%.*]], <2 x i8> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
 623 ; CHECK-NEXT:    [[X1:%.*]] = extractelement <2 x i8> [[X]], i32 [[INDEX:%.*]]
 624 ; CHECK-NEXT:    [[V1:%.*]] = insertelement <4 x i8> [[V0]], i8 [[X1]], i32 [[INDEX]]
 625 ; CHECK-NEXT:    [[V2:%.*]] = insertelement <4 x i8> [[V1]], i8 [[Y:%.*]], i32 2
 626 ; CHECK-NEXT:    ret <4 x i8> [[V2]]
 627 ;
 628   %v0 = shufflevector <2 x i8> %x, <2 x i8> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
 629   %x1 = extractelement <2 x i8> %x, i32 %index
 630   %v1 = insertelement <4 x i8> %v0, i8 %x1, i32 %index
 631   %v2 = insertelement <4 x i8> %v1, i8 %y, i32 2
 632   ret <4 x i8> %v2
 633 }
 634
 635 ; Negative test - don't create arbitrary shuffle masks.
 636
 637 define <4 x i8> @shuf_identity_padding_wrong_source_vec(<2 x i8> %x, i8 %y, <2 x i8> %other) {
 638 ; CHECK-LABEL: @shuf_identity_padding_wrong_source_vec(
 639 ; CHECK-NEXT:    [[V0:%.*]] = shufflevector <2 x i8> [[X:%.*]], <2 x i8> undef, <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
 640 ; CHECK-NEXT:    [[X1:%.*]] = extractelement <2 x i8> [[OTHER:%.*]], i32 1
 641 ; CHECK-NEXT:    [[V1:%.*]] = insertelement <4 x i8> [[V0]], i8 [[X1]], i32 1
 642 ; CHECK-NEXT:    [[V2:%.*]] = insertelement <4 x i8> [[V1]], i8 [[Y:%.*]], i32 2
 643 ; CHECK-NEXT:    ret <4 x i8> [[V2]]
 644 ;
 645   %v0 = shufflevector <2 x i8> %x, <2 x i8> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
 646   %x1 = extractelement <2 x i8> %other, i32 1
 647   %v1 = insertelement <4 x i8> %v0, i8 %x1, i32 1
 648   %v2 = insertelement <4 x i8> %v1, i8 %y, i32 2
 649   ret <4 x i8> %v2
 650 }
 651
 652 ; Negative test - don't create arbitrary shuffle masks.
 653
 654 define <4 x i8> @shuf_identity_padding_wrong_index(<2 x i8> %x, i8 %y) {
 655 ; CHECK-LABEL: @shuf_identity_padding_wrong_index(
 656 ; CHECK-NEXT:    [[V0:%.*]] = shufflevector <2 x i8> [[X:%.*]], <2 x i8> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
 657 ; CHECK-NEXT:    [[X1:%.*]] = extractelement <2 x i8> [[X]], i32 1
 658 ; CHECK-NEXT:    [[V1:%.*]] = insertelement <4 x i8> [[V0]], i8 [[X1]], i32 2
 659 ; CHECK-NEXT:    [[V2:%.*]] = insertelement <4 x i8> [[V1]], i8 [[Y:%.*]], i32 3
 660 ; CHECK-NEXT:    ret <4 x i8> [[V2]]
 661 ;
 662   %v0 = shufflevector <2 x i8> %x, <2 x i8> undef, <4 x i32> <i32 0, i32 1, i32 undef, i32 undef>
 663   %x1 = extractelement <2 x i8> %x, i32 1
 664   %v1 = insertelement <4 x i8> %v0, i8 %x1, i32 2
 665   %v2 = insertelement <4 x i8> %v1, i8 %y, i32 3
 666   ret <4 x i8> %v2
 667 }