[Scalarizer] Use poison as insertelement's placeholder

[aqjune]

Summary

This patch makes Scalarizer to use poison as insertelement's placeholder.

It contains two changes in Scalarizer.cpp, and the both changes does not change the semantics of the optimized program.
It is because the placeholder value (poison) is already completely hidden by following insertelement instructions.

The first change at visitBitCastInst() creates poison vector of MidTy and consecutively inserts FanIn times,
which is # of elems of MidTy.
The second change at ScalarizerVisitor::finish() creates poison with Op->getType(), and it is filled with
Count insertelements.

The test diffs show that the poison value is never exposed after insertelements.

[nikic]

LGTM

llvm/lib/Transforms/Scalar/Scalarizer.cpp

 //===- Scalarizer.cpp - Scalarize vector operations -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
for (unsigned Op0I = 0; Op0I < SrcNumElems; ++Op0I) {
         Res[ResI++] = Mid[MidI];
     }
   } else {
     // <N*M x t1> -> <M x t2>.  Convert each group of <N x t1> into a t2.
     unsigned FanIn = SrcNumElems / DstNumElems;
     auto *MidTy = FixedVectorType::get(SrcVT->getElementType(), FanIn);
     unsigned Op0I = 0;
     for (unsigned ResI = 0; ResI < DstNumElems; ++ResI) {
-      Value *V = UndefValue::get(MidTy);
+      Value *V = PoisonValue::get(MidTy);
       for (unsigned MidI = 0; MidI < FanIn; ++MidI)
         V = Builder.CreateInsertElement(V, Op0[Op0I++], Builder.getInt32(MidI),
                                         BCI.getName() + ".i" + Twine(ResI)
                                         + ".upto" + Twine(MidI));
       Res[ResI] = Builder.CreateBitCast(V, DstVT->getElementType(),
                                         BCI.getName() + ".i" + Twine(ResI));
     }
   }
bool ScalarizerVisitor::finish() {
   if (Gathered.empty() && Scattered.empty())
     return false;
   for (const auto &GMI : Gathered) {
     Instruction *Op = GMI.first;
     ValueVector &CV = *GMI.second;
     if (!Op->use_empty()) {
       // The value is still needed, so recreate it using a series of
       // InsertElements.
-      Value *Res = UndefValue::get(Op->getType());
+      Value *Res = PoisonValue::get(Op->getType());
       if (auto *Ty = dyn_cast<VectorType>(Op->getType())) {
         BasicBlock *BB = Op->getParent();
         unsigned Count = cast<FixedVectorType>(Ty)->getNumElements();
         IRBuilder<> Builder(Op);
         if (isa<PHINode>(Op))
           Builder.SetInsertPoint(BB, BB->getFirstInsertionPt());
         for (unsigned I = 0; I < Count; ++I)
           Res = Builder.CreateInsertElement(Res, CV[I], Builder.getInt32(I),

llvm/test/Transforms/Scalarizer/basic-inseltpoison.ll

 ; CHECK:   %ptr.i2 = getelementptr float, float* %ptr.i0, i32 2
 ; CHECK:   %val.i2 = load float, float* %ptr.i2, align 8
 ; CHECK:   %ptr.i3 = getelementptr float, float* %ptr.i0, i32 3
 ; CHECK:   %val.i3 = load float, float* %ptr.i3, align 4
 ; CHECK:   %add.i0 = fadd float %val.i0, %val.i2
 ; CHECK:   %add.i1 = fadd float %val.i1, %val.i3
 ; CHECK:   %add.i2 = fadd float %acc.i0, %acc.i2
 ; CHECK:   %add.i3 = fadd float %acc.i1, %acc.i3
-; CHECK:   %add.upto0 = insertelement <4 x float> undef, float %add.i0, i32 0
+; CHECK:   %add.upto0 = insertelement <4 x float> poison, float %add.i0, i32 0
 ; CHECK:   %add.upto1 = insertelement <4 x float> %add.upto0, float %add.i1, i32 1
 ; CHECK:   %add.upto2 = insertelement <4 x float> %add.upto1, float %add.i2, i32 2
 ; CHECK:   %add = insertelement <4 x float> %add.upto2, float %add.i3, i32 3
 ; CHECK:   %call = call <4 x float> @ext(<4 x float> %add)
 ; CHECK:   %call.i0 = extractelement <4 x float> %call, i32 0
 ; CHECK:   %cmp.i0 = fcmp ogt float %call.i0, 1.0
 ; CHECK:   %call.i1 = extractelement <4 x float> %call, i32 1
 ; CHECK:   %cmp.i1 = fcmp ogt float %call.i1, 2.0

 ; CHECK: %x.i0 = extractelement <4 x float> %x, i32 0
 ; CHECK: %res.i0 = fadd float %x.i0, 1.0{{[e+0]*}}, !fpmath ![[TAG:[0-9]*]]
 ; CHECK: %x.i1 = extractelement <4 x float> %x, i32 1
 ; CHECK: %res.i1 = fadd float %x.i1, 2.0{{[e+0]*}}, !fpmath ![[TAG]]
 ; CHECK: %x.i2 = extractelement <4 x float> %x, i32 2
 ; CHECK: %res.i2 = fadd float %x.i2, 3.0{{[e+0]*}}, !fpmath ![[TAG]]
 ; CHECK: %x.i3 = extractelement <4 x float> %x, i32 3
 ; CHECK: %res.i3 = fadd float %x.i3, 4.0{{[e+0]*}}, !fpmath ![[TAG]]
-; CHECK: %res.upto0 = insertelement <4 x float> undef, float %res.i0, i32 0
+; CHECK: %res.upto0 = insertelement <4 x float> poison, float %res.i0, i32 0
 ; CHECK: %res.upto1 = insertelement <4 x float> %res.upto0, float %res.i1, i32 1
 ; CHECK: %res.upto2 = insertelement <4 x float> %res.upto1, float %res.i2, i32 2
 ; CHECK: %res = insertelement <4 x float> %res.upto2, float %res.i3, i32 3
 ; CHECK: ret <4 x float> %res
   %res = fadd <4 x float> %x, <float 1.0, float 2.0, float 3.0, float 4.0>,
     !fpmath !4
   ret <4 x float> %res
 }

 ; Test combinations of vector and non-vector PHIs.
 define <4 x float> @f14(<4 x float> %acc, i32 %count) {
 ; CHECK-LABEL: @f14(
 ; CHECK: %this_acc.i0 = phi float [ %acc.i0, %entry ], [ %next_acc.i0, %loop ]
 ; CHECK: %this_acc.i1 = phi float [ %acc.i1, %entry ], [ %next_acc.i1, %loop ]
 ; CHECK: %this_acc.i2 = phi float [ %acc.i2, %entry ], [ %next_acc.i2, %loop ]
 ; CHECK: %this_acc.i3 = phi float [ %acc.i3, %entry ], [ %next_acc.i3, %loop ]
 ; CHECK: %this_count = phi i32 [ %count, %entry ], [ %next_count, %loop ]
-; CHECK: %this_acc.upto0 = insertelement <4 x float> undef, float %this_acc.i0, i32 0
+; CHECK: %this_acc.upto0 = insertelement <4 x float> poison, float %this_acc.i0, i32 0
 ; CHECK: %this_acc.upto1 = insertelement <4 x float> %this_acc.upto0, float %this_acc.i1, i32 1
 ; CHECK: %this_acc.upto2 = insertelement <4 x float> %this_acc.upto1, float %this_acc.i2, i32 2
 ; CHECK: %this_acc = insertelement <4 x float> %this_acc.upto2, float %this_acc.i3, i32 3
 ; CHECK: ret <4 x float> %next_acc
 entry:
   br label %loop
 
 loop:

 ; CHECK: %ptr.i2 = getelementptr float, float* %ptr.i0, i32 2
 ; CHECK: %val.i2 = load float, float* %ptr.i2, align 8
 ; CHECK: %ptr.i3 = getelementptr float, float* %ptr.i0, i32 3
 ; CHECK: %val.i3 = load float, float* %ptr.i3, align 4
 ; CHECK: %neg.i0 = fneg float %val.i0
 ; CHECK: %neg.i1 = fneg float %val.i1
 ; CHECK: %neg.i2 = fneg float %val.i2
 ; CHECK: %neg.i3 = fneg float %val.i3
-; CHECK: %neg.upto0 = insertelement <4 x float> undef, float %neg.i0, i32 0
+; CHECK: %neg.upto0 = insertelement <4 x float> poison, float %neg.i0, i32 0
 ; CHECK: %neg.upto1 = insertelement <4 x float> %neg.upto0, float %neg.i1, i32 1
 ; CHECK: %neg.upto2 = insertelement <4 x float> %neg.upto1, float %neg.i2, i32 2
 ; CHECK: %neg = insertelement <4 x float> %neg.upto2, float %neg.i3, i32 3
 ; CHECK: %call = call <4 x float> @ext(<4 x float> %neg)
 ; CHECK: %call.i0 = extractelement <4 x float> %call, i32 0
 ; CHECK: %cmp.i0 = fcmp ogt float %call.i0, 1.000000e+00
 ; CHECK: %call.i1 = extractelement <4 x float> %call, i32 1
 ; CHECK: %cmp.i1 = fcmp ogt float %call.i1, 2.000000e+00
; CHECK: %res.i1 = call fast float @llvm.fma.f32
   %res = call fast <2 x float> @llvm.fma.v2f32(<2 x float> %x, <2 x float> %y, <2 x float> %z)
   ret <2 x float> %res
 }
 
 ; See https://reviews.llvm.org/D83101#2133062
 define <2 x i32> @f23_crash(<2 x i32> %srcvec, i32 %v1) {
 ; CHECK-LABEL: @f23_crash(
 ; CHECK: %v0 = extractelement <2 x i32> %srcvec, i32 0
-; CHECK: %t1.upto0 = insertelement <2 x i32> undef, i32 %v0, i32 0
+; CHECK: %t1.upto0 = insertelement <2 x i32> poison, i32 %v0, i32 0
 ; CHECK: %t1 = insertelement <2 x i32> %t1.upto0, i32 %v1, i32 1
 ; CHECK: ret <2 x i32> %t1
   %v0 = extractelement <2 x i32> %srcvec, i32 0
   %t0 = insertelement <2 x i32> poison, i32 %v0, i32 0
   %t1 = insertelement <2 x i32> %t0, i32 %v1, i32 1
   ret <2 x i32> %t1
 }
 
 !0 = !{ !"root" }
 !1 = !{ !"set1", !0 }
 !2 = !{ !"set2", !0 }
 !3 = !{ !3, !{!"llvm.loop.parallel_accesses", !13} }
 !4 = !{ float 4.0 }
 !5 = !{ i64 0, i64 8, null }
 !13 = distinct !{}

llvm/test/Transforms/Scalarizer/basic.ll

 ; CHECK:   %ptr.i2 = getelementptr float, float* %ptr.i0, i32 2
 ; CHECK:   %val.i2 = load float, float* %ptr.i2, align 8
 ; CHECK:   %ptr.i3 = getelementptr float, float* %ptr.i0, i32 3
 ; CHECK:   %val.i3 = load float, float* %ptr.i3, align 4
 ; CHECK:   %add.i0 = fadd float %val.i0, %val.i2
 ; CHECK:   %add.i1 = fadd float %val.i1, %val.i3
 ; CHECK:   %add.i2 = fadd float %acc.i0, %acc.i2
 ; CHECK:   %add.i3 = fadd float %acc.i1, %acc.i3
-; CHECK:   %add.upto0 = insertelement <4 x float> undef, float %add.i0, i32 0
+; CHECK:   %add.upto0 = insertelement <4 x float> poison, float %add.i0, i32 0
 ; CHECK:   %add.upto1 = insertelement <4 x float> %add.upto0, float %add.i1, i32 1
 ; CHECK:   %add.upto2 = insertelement <4 x float> %add.upto1, float %add.i2, i32 2
 ; CHECK:   %add = insertelement <4 x float> %add.upto2, float %add.i3, i32 3
 ; CHECK:   %call = call <4 x float> @ext(<4 x float> %add)
 ; CHECK:   %call.i0 = extractelement <4 x float> %call, i32 0
 ; CHECK:   %cmp.i0 = fcmp ogt float %call.i0, 1.0
 ; CHECK:   %call.i1 = extractelement <4 x float> %call, i32 1
 ; CHECK:   %cmp.i1 = fcmp ogt float %call.i1, 2.0

 ; CHECK: %x.i0 = extractelement <4 x float> %x, i32 0
 ; CHECK: %res.i0 = fadd float %x.i0, 1.0{{[e+0]*}}, !fpmath ![[TAG:[0-9]*]]
 ; CHECK: %x.i1 = extractelement <4 x float> %x, i32 1
 ; CHECK: %res.i1 = fadd float %x.i1, 2.0{{[e+0]*}}, !fpmath ![[TAG]]
 ; CHECK: %x.i2 = extractelement <4 x float> %x, i32 2
 ; CHECK: %res.i2 = fadd float %x.i2, 3.0{{[e+0]*}}, !fpmath ![[TAG]]
 ; CHECK: %x.i3 = extractelement <4 x float> %x, i32 3
 ; CHECK: %res.i3 = fadd float %x.i3, 4.0{{[e+0]*}}, !fpmath ![[TAG]]
-; CHECK: %res.upto0 = insertelement <4 x float> undef, float %res.i0, i32 0
+; CHECK: %res.upto0 = insertelement <4 x float> poison, float %res.i0, i32 0
 ; CHECK: %res.upto1 = insertelement <4 x float> %res.upto0, float %res.i1, i32 1
 ; CHECK: %res.upto2 = insertelement <4 x float> %res.upto1, float %res.i2, i32 2
 ; CHECK: %res = insertelement <4 x float> %res.upto2, float %res.i3, i32 3
 ; CHECK: ret <4 x float> %res
   %res = fadd <4 x float> %x, <float 1.0, float 2.0, float 3.0, float 4.0>,
     !fpmath !4
   ret <4 x float> %res
 }

 ; Test combinations of vector and non-vector PHIs.
 define <4 x float> @f14(<4 x float> %acc, i32 %count) {
 ; CHECK-LABEL: @f14(
 ; CHECK: %this_acc.i0 = phi float [ %acc.i0, %entry ], [ %next_acc.i0, %loop ]
 ; CHECK: %this_acc.i1 = phi float [ %acc.i1, %entry ], [ %next_acc.i1, %loop ]
 ; CHECK: %this_acc.i2 = phi float [ %acc.i2, %entry ], [ %next_acc.i2, %loop ]
 ; CHECK: %this_acc.i3 = phi float [ %acc.i3, %entry ], [ %next_acc.i3, %loop ]
 ; CHECK: %this_count = phi i32 [ %count, %entry ], [ %next_count, %loop ]
-; CHECK: %this_acc.upto0 = insertelement <4 x float> undef, float %this_acc.i0, i32 0
+; CHECK: %this_acc.upto0 = insertelement <4 x float> poison, float %this_acc.i0, i32 0
 ; CHECK: %this_acc.upto1 = insertelement <4 x float> %this_acc.upto0, float %this_acc.i1, i32 1
 ; CHECK: %this_acc.upto2 = insertelement <4 x float> %this_acc.upto1, float %this_acc.i2, i32 2
 ; CHECK: %this_acc = insertelement <4 x float> %this_acc.upto2, float %this_acc.i3, i32 3
 ; CHECK: ret <4 x float> %next_acc
 entry:
   br label %loop
 
 loop:

 ; CHECK: %ptr.i2 = getelementptr float, float* %ptr.i0, i32 2
 ; CHECK: %val.i2 = load float, float* %ptr.i2, align 8
 ; CHECK: %ptr.i3 = getelementptr float, float* %ptr.i0, i32 3
 ; CHECK: %val.i3 = load float, float* %ptr.i3, align 4
 ; CHECK: %neg.i0 = fneg float %val.i0
 ; CHECK: %neg.i1 = fneg float %val.i1
 ; CHECK: %neg.i2 = fneg float %val.i2
 ; CHECK: %neg.i3 = fneg float %val.i3
-; CHECK: %neg.upto0 = insertelement <4 x float> undef, float %neg.i0, i32 0
+; CHECK: %neg.upto0 = insertelement <4 x float> poison, float %neg.i0, i32 0
 ; CHECK: %neg.upto1 = insertelement <4 x float> %neg.upto0, float %neg.i1, i32 1
 ; CHECK: %neg.upto2 = insertelement <4 x float> %neg.upto1, float %neg.i2, i32 2
 ; CHECK: %neg = insertelement <4 x float> %neg.upto2, float %neg.i3, i32 3
 ; CHECK: %call = call <4 x float> @ext(<4 x float> %neg)
 ; CHECK: %call.i0 = extractelement <4 x float> %call, i32 0
 ; CHECK: %cmp.i0 = fcmp ogt float %call.i0, 1.000000e+00
 ; CHECK: %call.i1 = extractelement <4 x float> %call, i32 1
 ; CHECK: %cmp.i1 = fcmp ogt float %call.i1, 2.000000e+00
; CHECK: %res.i1 = call fast float @llvm.fma.f32
   %res = call fast <2 x float> @llvm.fma.v2f32(<2 x float> %x, <2 x float> %y, <2 x float> %z)
   ret <2 x float> %res
 }
 
 ; See https://reviews.llvm.org/D83101#2133062
 define <2 x i32> @f23_crash(<2 x i32> %srcvec, i32 %v1) {
 ; CHECK-LABEL: @f23_crash(
 ; CHECK: %v0 = extractelement <2 x i32> %srcvec, i32 0
-; CHECK: %t1.upto0 = insertelement <2 x i32> undef, i32 %v0, i32 0
+; CHECK: %t1.upto0 = insertelement <2 x i32> poison, i32 %v0, i32 0
 ; CHECK: %t1 = insertelement <2 x i32> %t1.upto0, i32 %v1, i32 1
 ; CHECK: ret <2 x i32> %t1
   %v0 = extractelement <2 x i32> %srcvec, i32 0
   %t0 = insertelement <2 x i32> undef, i32 %v0, i32 0
   %t1 = insertelement <2 x i32> %t0, i32 %v1, i32 1
   ret <2 x i32> %t1
 }
 
 !0 = !{ !"root" }
 !1 = !{ !"set1", !0 }
 !2 = !{ !"set2", !0 }
 !3 = !{ !3, !{!"llvm.loop.parallel_accesses", !13} }
 !4 = !{ float 4.0 }
 !5 = !{ i64 0, i64 8, null }
 !13 = distinct !{}

llvm/test/Transforms/Scalarizer/constant-insertelement.ll

 ; ALL-NEXT:    [[SRC_I1:%.*]] = getelementptr i32, i32* [[SRC_I0]], i32 1
 ; ALL-NEXT:    [[VAL0_I1:%.*]] = load i32, i32* [[SRC_I1]], align 4
 ; ALL-NEXT:    [[SRC_I2:%.*]] = getelementptr i32, i32* [[SRC_I0]], i32 2
 ; ALL-NEXT:    [[VAL0_I2:%.*]] = load i32, i32* [[SRC_I2]], align 8
 ; ALL-NEXT:    [[VAL2_I0:%.*]] = shl i32 1, [[VAL0_I0]]
 ; ALL-NEXT:    [[VAL2_I1:%.*]] = shl i32 2, [[VAL0_I1]]
 ; ALL-NEXT:    [[VAL2_I2:%.*]] = shl i32 3, [[VAL0_I2]]
 ; ALL-NEXT:    [[VAL2_I3:%.*]] = shl i32 4, [[REPL:%.*]]
-; ALL-NEXT:    [[VAL2_UPTO0:%.*]] = insertelement <4 x i32> undef, i32 [[VAL2_I0]], i32 0
+; ALL-NEXT:    [[VAL2_UPTO0:%.*]] = insertelement <4 x i32> poison, i32 [[VAL2_I0]], i32 0
 ; ALL-NEXT:    [[VAL2_UPTO1:%.*]] = insertelement <4 x i32> [[VAL2_UPTO0]], i32 [[VAL2_I1]], i32 1
 ; ALL-NEXT:    [[VAL2_UPTO2:%.*]] = insertelement <4 x i32> [[VAL2_UPTO1]], i32 [[VAL2_I2]], i32 2
 ; ALL-NEXT:    [[VAL2:%.*]] = insertelement <4 x i32> [[VAL2_UPTO2]], i32 [[VAL2_I3]], i32 3
 ; ALL-NEXT:    ret <4 x i32> [[VAL2]]
 ;
   %val0 = load <4 x i32> , <4 x i32> *%src
   %val1 = insertelement <4 x i32> %val0, i32 %repl, i32 3
   %val2 = shl <4 x i32> <i32 1, i32 2, i32 3, i32 4>, %val1
   ret <4 x i32> %val2
 }

llvm/test/Transforms/Scalarizer/intrinsics.ll

 ; Binary int plus constant scalar operand
 declare <2 x i32> @llvm.smul.fix.sat.v2i32(<2 x i32>, <2 x i32>, i32)
 declare <2 x i32> @llvm.umul.fix.sat.v2i32(<2 x i32>, <2 x i32>, i32)
 
 
 ; CHECK-LABEL: @scalarize_sqrt_v2f32(
 ; CHECK: %sqrt.i0 = call float @llvm.sqrt.f32(float %x.i0)
 ; CHECK: %sqrt.i1 = call float @llvm.sqrt.f32(float %x.i1)
-; CHECK: %sqrt.upto0 = insertelement <2 x float> undef, float %sqrt.i0, i32 0
+; CHECK: %sqrt.upto0 = insertelement <2 x float> poison, float %sqrt.i0, i32 0
 ; CHECK: %sqrt = insertelement <2 x float> %sqrt.upto0, float %sqrt.i1, i32 1
 ; CHECK: ret <2 x float> %sqrt
 define <2 x float> @scalarize_sqrt_v2f32(<2 x float> %x) #0 {
   %sqrt = call <2 x float> @llvm.sqrt.v2f32(<2 x float> %x)
   ret <2 x float> %sqrt
 }
 
 ; CHECK-LABEL: @scalarize_minnum_v2f32(
 ; CHECK: %minnum.i0 = call float @llvm.minnum.f32(float %x.i0, float %y.i0)
 ; CHECK: %minnum.i1 = call float @llvm.minnum.f32(float %x.i1, float %y.i1)
-; CHECK: %minnum.upto0 = insertelement <2 x float> undef, float %minnum.i0, i32 0
+; CHECK: %minnum.upto0 = insertelement <2 x float> poison, float %minnum.i0, i32 0
 ; CHECK: %minnum = insertelement <2 x float> %minnum.upto0, float %minnum.i1, i32 1
 ; CHECK: ret <2 x float> %minnum
 define <2 x float> @scalarize_minnum_v2f32(<2 x float> %x, <2 x float> %y) #0 {
   %minnum = call <2 x float> @llvm.minnum.v2f32(<2 x float> %x, <2 x float> %y)
   ret <2 x float> %minnum
 }
 
 ; CHECK-LABEL: @scalarize_minimum_v2f32(
 ; CHECK: %minimum.i0 = call float @llvm.minimum.f32(float %x.i0, float %y.i0)
 ; CHECK: %minimum.i1 = call float @llvm.minimum.f32(float %x.i1, float %y.i1)
-; CHECK: %minimum.upto0 = insertelement <2 x float> undef, float %minimum.i0, i32 0
+; CHECK: %minimum.upto0 = insertelement <2 x float> poison, float %minimum.i0, i32 0
 ; CHECK: %minimum = insertelement <2 x float> %minimum.upto0, float %minimum.i1, i32 1
 ; CHECK: ret <2 x float> %minimum
 define <2 x float> @scalarize_minimum_v2f32(<2 x float> %x, <2 x float> %y) #0 {
   %minimum = call <2 x float> @llvm.minimum.v2f32(<2 x float> %x, <2 x float> %y)
   ret <2 x float> %minimum
 }
 
 ; CHECK-LABEL: @scalarize_maximum_v2f32(
 ; CHECK: %maximum.i0 = call float @llvm.maximum.f32(float %x.i0, float %y.i0)
 ; CHECK: %maximum.i1 = call float @llvm.maximum.f32(float %x.i1, float %y.i1)
-; CHECK: %maximum.upto0 = insertelement <2 x float> undef, float %maximum.i0, i32 0
+; CHECK: %maximum.upto0 = insertelement <2 x float> poison, float %maximum.i0, i32 0
 ; CHECK: %maximum = insertelement <2 x float> %maximum.upto0, float %maximum.i1, i32 1
 ; CHECK: ret <2 x float> %maximum
 define <2 x float> @scalarize_maximum_v2f32(<2 x float> %x, <2 x float> %y) #0 {
   %maximum = call <2 x float> @llvm.maximum.v2f32(<2 x float> %x, <2 x float> %y)
   ret <2 x float> %maximum
 }
 
 ; CHECK-LABEL: @scalarize_fma_v2f32(
 ; CHECK: %fma.i0 = call float @llvm.fma.f32(float %x.i0, float %y.i0, float %z.i0)
 ; CHECK: %fma.i1 = call float @llvm.fma.f32(float %x.i1, float %y.i1, float %z.i1)
-; CHECK: %fma.upto0 = insertelement <2 x float> undef, float %fma.i0, i32 0
+; CHECK: %fma.upto0 = insertelement <2 x float> poison, float %fma.i0, i32 0
 ; CHECK: %fma = insertelement <2 x float> %fma.upto0, float %fma.i1, i32 1
 ; CHECK: ret <2 x float> %fma
 define <2 x float> @scalarize_fma_v2f32(<2 x float> %x, <2 x float> %y, <2 x float> %z) #0 {
   %fma = call <2 x float> @llvm.fma.v2f32(<2 x float> %x, <2 x float> %y, <2 x float> %z)
   ret <2 x float> %fma
 }
 
 ; CHECK-LABEL: @scalarize_bswap_v2i32(
 ; CHECK: %bswap.i0 = call i32 @llvm.bswap.i32(i32 %x.i0)
 ; CHECK: %bswap.i1 = call i32 @llvm.bswap.i32(i32 %x.i1)
-; CHECK: %bswap.upto0 = insertelement <2 x i32> undef, i32 %bswap.i0, i32 0
+; CHECK: %bswap.upto0 = insertelement <2 x i32> poison, i32 %bswap.i0, i32 0
 ; CHECK: %bswap = insertelement <2 x i32> %bswap.upto0, i32 %bswap.i1, i32 1
 ; CHECK: ret <2 x i32> %bswap
 define <2 x i32> @scalarize_bswap_v2i32(<2 x i32> %x) #0 {
   %bswap = call <2 x i32> @llvm.bswap.v2i32(<2 x i32> %x)
   ret <2 x i32> %bswap
 }
 
 ; CHECK-LABEL: @scalarize_ctlz_v2i32(
 ; CHECK: %ctlz.i0 = call i32 @llvm.ctlz.i32(i32 %x.i0, i1 true)
 ; CHECK: %ctlz.i1 = call i32 @llvm.ctlz.i32(i32 %x.i1, i1 true)
-; CHECK: %ctlz.upto0 = insertelement <2 x i32> undef, i32 %ctlz.i0, i32 0
+; CHECK: %ctlz.upto0 = insertelement <2 x i32> poison, i32 %ctlz.i0, i32 0
 ; CHECK: %ctlz = insertelement <2 x i32> %ctlz.upto0, i32 %ctlz.i1, i32 1
 ; CHECK: ret <2 x i32> %ctlz
 define <2 x i32> @scalarize_ctlz_v2i32(<2 x i32> %x) #0 {
   %ctlz = call <2 x i32> @llvm.ctlz.v2i32(<2 x i32> %x, i1 true)
   ret <2 x i32> %ctlz
 }
 
 ; CHECK-LABEL: @scalarize_powi_v2f32(
 ; CHECK: %powi.i0 = call float @llvm.powi.f32(float %x.i0, i32 %y)
 ; CHECK: %powi.i1 = call float @llvm.powi.f32(float %x.i1, i32 %y)
-; CHECK: %powi.upto0 = insertelement <2 x float> undef, float %powi.i0, i32 0
+; CHECK: %powi.upto0 = insertelement <2 x float> poison, float %powi.i0, i32 0
 ; CHECK: %powi = insertelement <2 x float> %powi.upto0, float %powi.i1, i32 1
 ; CHECK: ret <2 x float> %powi
 define <2 x float> @scalarize_powi_v2f32(<2 x float> %x, i32 %y) #0 {
   %powi = call <2 x float> @llvm.powi.v2f32(<2 x float> %x, i32 %y)
   ret <2 x float> %powi
 }
 
 ; CHECK-LABEL: @scalarize_smul_fix_sat_v2i32(
 ; CHECK: %smulfixsat.i0 = call i32 @llvm.smul.fix.sat.i32(i32 %x.i0, i32 5, i32 31)
 ; CHECK: %smulfixsat.i1 = call i32 @llvm.smul.fix.sat.i32(i32 %x.i1, i32 19, i32 31)
-; CHECK: %smulfixsat.upto0 = insertelement <2 x i32> undef, i32 %smulfixsat.i0, i32 0
+; CHECK: %smulfixsat.upto0 = insertelement <2 x i32> poison, i32 %smulfixsat.i0, i32 0
 ; CHECK: %smulfixsat = insertelement <2 x i32> %smulfixsat.upto0, i32 %smulfixsat.i1, i32 1
 ; CHECK: ret <2 x i32> %smulfixsat
 define <2 x i32> @scalarize_smul_fix_sat_v2i32(<2 x i32> %x) #0 {
   %smulfixsat = call <2 x i32> @llvm.smul.fix.sat.v2i32(<2 x i32> %x, <2 x i32> <i32 5, i32 19>, i32 31)
   ret <2 x i32> %smulfixsat
 }
 
 ; CHECK-LABEL: @scalarize_umul_fix_sat_v2i32(
 ; CHECK: %umulfixsat.i0 = call i32 @llvm.umul.fix.sat.i32(i32 %x.i0, i32 5, i32 31)
 ; CHECK: %umulfixsat.i1 = call i32 @llvm.umul.fix.sat.i32(i32 %x.i1, i32 19, i32 31)
-; CHECK: %umulfixsat.upto0 = insertelement <2 x i32> undef, i32 %umulfixsat.i0, i32 0
+; CHECK: %umulfixsat.upto0 = insertelement <2 x i32> poison, i32 %umulfixsat.i0, i32 0
 ; CHECK: %umulfixsat = insertelement <2 x i32> %umulfixsat.upto0, i32 %umulfixsat.i1, i32 1
 ; CHECK: ret <2 x i32> %umulfixsat
 define <2 x i32> @scalarize_umul_fix_sat_v2i32(<2 x i32> %x) #0 {
   %umulfixsat = call <2 x i32> @llvm.umul.fix.sat.v2i32(<2 x i32> %x, <2 x i32> <i32 5, i32 19>, i32 31)
   ret <2 x i32> %umulfixsat
 }

llvm/test/Transforms/Scalarizer/order-bug-inseltpoison.ll

 ; RUN: opt %s -scalarizer -S -o - | FileCheck %s
 ; RUN: opt %s -passes='function(scalarizer)' -S -o - | FileCheck %s
 
 ; This input caused the scalarizer to replace & erase gathered results when 
 ; future gathered results depended on them being alive
 
 define dllexport spir_func <4 x i32> @main(float %a) {
 entry:
   %i = insertelement <4 x float> poison, float %a, i32 0
   br label %z
 
 y:
-; CHECK: %f.upto0 = insertelement <4 x i32> undef, i32 %b.i0, i32 0
+; CHECK: %f.upto0 = insertelement <4 x i32> poison, i32 %b.i0, i32 0
 ; CHECK: %f.upto1 = insertelement <4 x i32> %f.upto0, i32 %b.i0, i32 1
 ; CHECK: %f.upto2 = insertelement <4 x i32> %f.upto1, i32 %b.i0, i32 2
 ; CHECK: %f = insertelement <4 x i32> %f.upto2, i32 %b.i0, i32 3
   %f = shufflevector <4 x i32> %b, <4 x i32> poison, <4 x i32> zeroinitializer
   ret <4 x i32> %f
 
 z:
 ; CHECK: %b.i0 = bitcast float %a to i32
   %b = bitcast <4 x float> %i to <4 x i32>
   br label %y
 }

llvm/test/Transforms/Scalarizer/order-bug.ll

 ; RUN: opt %s -scalarizer -S -o - | FileCheck %s
 ; RUN: opt %s -passes='function(scalarizer)' -S -o - | FileCheck %s
 
 ; This input caused the scalarizer to replace & erase gathered results when 
 ; future gathered results depended on them being alive
 
 define dllexport spir_func <4 x i32> @main(float %a) {
 entry:
   %i = insertelement <4 x float> undef, float %a, i32 0
   br label %z
 
 y:
-; CHECK: %f.upto0 = insertelement <4 x i32> undef, i32 %b.i0, i32 0
+; CHECK: %f.upto0 = insertelement <4 x i32> poison, i32 %b.i0, i32 0
 ; CHECK: %f.upto1 = insertelement <4 x i32> %f.upto0, i32 %b.i0, i32 1
 ; CHECK: %f.upto2 = insertelement <4 x i32> %f.upto1, i32 %b.i0, i32 2
 ; CHECK: %f = insertelement <4 x i32> %f.upto2, i32 %b.i0, i32 3
   %f = shufflevector <4 x i32> %b, <4 x i32> undef, <4 x i32> zeroinitializer
   ret <4 x i32> %f
 
 z:
 ; CHECK: %b.i0 = bitcast float %a to i32
   %b = bitcast <4 x float> %i to <4 x i32>
   br label %y
 }

llvm/test/Transforms/Scalarizer/scatter-order.ll

 define <2 x i32> @test1(i1 %b, <2 x i32> %i, <2 x i32> %j) {
 ; CHECK-LABEL: @test1(
 ; CHECK-NEXT:    [[I_I0:%.*]] = extractelement <2 x i32> [[I:%.*]], i32 0
 ; CHECK-NEXT:    [[J_I0:%.*]] = extractelement <2 x i32> [[J:%.*]], i32 0
 ; CHECK-NEXT:    [[RES_I0:%.*]] = select i1 [[B:%.*]], i32 [[I_I0]], i32 [[J_I0]]
 ; CHECK-NEXT:    [[I_I1:%.*]] = extractelement <2 x i32> [[I]], i32 1
 ; CHECK-NEXT:    [[J_I1:%.*]] = extractelement <2 x i32> [[J]], i32 1
 ; CHECK-NEXT:    [[RES_I1:%.*]] = select i1 [[B]], i32 [[I_I1]], i32 [[J_I1]]
-; CHECK-NEXT:    [[RES_UPTO0:%.*]] = insertelement <2 x i32> undef, i32 [[RES_I0]], i32 0
+; CHECK-NEXT:    [[RES_UPTO0:%.*]] = insertelement <2 x i32> poison, i32 [[RES_I0]], i32 0
 ; CHECK-NEXT:    [[RES:%.*]] = insertelement <2 x i32> [[RES_UPTO0]], i32 [[RES_I1]], i32 1
 ; CHECK-NEXT:    ret <2 x i32> [[RES]]
 ;
   %res = select i1 %b, <2 x i32> %i, <2 x i32> %j
   ret <2 x i32> %res
 }
 
 define <2 x i32> @test2(<2 x i1> %b, <2 x i32> %i, <2 x i32> %j) {
 ; CHECK-LABEL: @test2(
 ; CHECK-NEXT:    [[B_I0:%.*]] = extractelement <2 x i1> [[B:%.*]], i32 0
 ; CHECK-NEXT:    [[I_I0:%.*]] = extractelement <2 x i32> [[I:%.*]], i32 0
 ; CHECK-NEXT:    [[J_I0:%.*]] = extractelement <2 x i32> [[J:%.*]], i32 0
 ; CHECK-NEXT:    [[RES_I0:%.*]] = select i1 [[B_I0]], i32 [[I_I0]], i32 [[J_I0]]
 ; CHECK-NEXT:    [[B_I1:%.*]] = extractelement <2 x i1> [[B]], i32 1
 ; CHECK-NEXT:    [[I_I1:%.*]] = extractelement <2 x i32> [[I]], i32 1
 ; CHECK-NEXT:    [[J_I1:%.*]] = extractelement <2 x i32> [[J]], i32 1
 ; CHECK-NEXT:    [[RES_I1:%.*]] = select i1 [[B_I1]], i32 [[I_I1]], i32 [[J_I1]]
-; CHECK-NEXT:    [[RES_UPTO0:%.*]] = insertelement <2 x i32> undef, i32 [[RES_I0]], i32 0
+; CHECK-NEXT:    [[RES_UPTO0:%.*]] = insertelement <2 x i32> poison, i32 [[RES_I0]], i32 0
 ; CHECK-NEXT:    [[RES:%.*]] = insertelement <2 x i32> [[RES_UPTO0]], i32 [[RES_I1]], i32 1
 ; CHECK-NEXT:    ret <2 x i32> [[RES]]
 ;
   %res = select <2 x i1> %b, <2 x i32> %i, <2 x i32> %j
   ret <2 x i32> %res
 }
 
 define <2 x i32> @test3(<2 x i32> %i, <2 x i32> %j) {
 ; CHECK-LABEL: @test3(
 ; CHECK-NEXT:    [[I_I0:%.*]] = extractelement <2 x i32> [[I:%.*]], i32 0
 ; CHECK-NEXT:    [[J_I0:%.*]] = extractelement <2 x i32> [[J:%.*]], i32 0
 ; CHECK-NEXT:    [[RES_I0:%.*]] = add nuw nsw i32 [[I_I0]], [[J_I0]]
 ; CHECK-NEXT:    [[I_I1:%.*]] = extractelement <2 x i32> [[I]], i32 1
 ; CHECK-NEXT:    [[J_I1:%.*]] = extractelement <2 x i32> [[J]], i32 1
 ; CHECK-NEXT:    [[RES_I1:%.*]] = add nuw nsw i32 [[I_I1]], [[J_I1]]
-; CHECK-NEXT:    [[RES_UPTO0:%.*]] = insertelement <2 x i32> undef, i32 [[RES_I0]], i32 0
+; CHECK-NEXT:    [[RES_UPTO0:%.*]] = insertelement <2 x i32> poison, i32 [[RES_I0]], i32 0
 ; CHECK-NEXT:    [[RES:%.*]] = insertelement <2 x i32> [[RES_UPTO0]], i32 [[RES_I1]], i32 1
 ; CHECK-NEXT:    ret <2 x i32> [[RES]]
 ;
   %res = add nuw nsw <2 x i32> %i, %j
   ret <2 x i32> %res
 }
 
 define void @test4(<2 x i32>* %ptr, <2 x i32> %val) {

llvm/test/Transforms/Scalarizer/variable-extractelement.ll

 ; OFF-NEXT:    [[VAL0_I0:%.*]] = extractelement <4 x i32> [[VAL0]], i32 0
 ; OFF-NEXT:    [[VAL1_I0:%.*]] = shl i32 1, [[VAL0_I0]]
 ; OFF-NEXT:    [[VAL0_I1:%.*]] = extractelement <4 x i32> [[VAL0]], i32 1
 ; OFF-NEXT:    [[VAL1_I1:%.*]] = shl i32 2, [[VAL0_I1]]
 ; OFF-NEXT:    [[VAL0_I2:%.*]] = extractelement <4 x i32> [[VAL0]], i32 2
 ; OFF-NEXT:    [[VAL1_I2:%.*]] = shl i32 3, [[VAL0_I2]]
 ; OFF-NEXT:    [[VAL0_I3:%.*]] = extractelement <4 x i32> [[VAL0]], i32 3
 ; OFF-NEXT:    [[VAL1_I3:%.*]] = shl i32 4, [[VAL0_I3]]
-; OFF-NEXT:    [[VAL1_UPTO0:%.*]] = insertelement <4 x i32> undef, i32 [[VAL1_I0]], i32 0
+; OFF-NEXT:    [[VAL1_UPTO0:%.*]] = insertelement <4 x i32> poison, i32 [[VAL1_I0]], i32 0
 ; OFF-NEXT:    [[VAL1_UPTO1:%.*]] = insertelement <4 x i32> [[VAL1_UPTO0]], i32 [[VAL1_I1]], i32 1
 ; OFF-NEXT:    [[VAL1_UPTO2:%.*]] = insertelement <4 x i32> [[VAL1_UPTO1]], i32 [[VAL1_I2]], i32 2
 ; OFF-NEXT:    [[VAL1:%.*]] = insertelement <4 x i32> [[VAL1_UPTO2]], i32 [[VAL1_I3]], i32 3
 ; OFF-NEXT:    [[VAL2:%.*]] = extractelement <4 x i32> [[VAL1]], i32 [[INDEX:%.*]]
 ; OFF-NEXT:    ret i32 [[VAL2]]
 ;
   %val0 = load <4 x i32> , <4 x i32> *%src
   %val1 = shl <4 x i32> <i32 1, i32 2, i32 3, i32 4>, %val0
   %val2 = extractelement <4 x i32> %val1, i32 %index
   ret i32 %val2
 }

llvm/test/Transforms/Scalarizer/variable-insertelement.ll

 ; DEFAULT-NEXT:    [[SRC_I1:%.*]] = extractelement <4 x i32> [[SRC]], i32 1
 ; DEFAULT-NEXT:    [[RES_I1:%.*]] = select i1 [[INDEX_IS_1]], i32 [[VAL]], i32 [[SRC_I1]]
 ; DEFAULT-NEXT:    [[INDEX_IS_2:%.*]] = icmp eq i32 [[INDEX]], 2
 ; DEFAULT-NEXT:    [[SRC_I2:%.*]] = extractelement <4 x i32> [[SRC]], i32 2
 ; DEFAULT-NEXT:    [[RES_I2:%.*]] = select i1 [[INDEX_IS_2]], i32 [[VAL]], i32 [[SRC_I2]]
 ; DEFAULT-NEXT:    [[INDEX_IS_3:%.*]] = icmp eq i32 [[INDEX]], 3
 ; DEFAULT-NEXT:    [[SRC_I3:%.*]] = extractelement <4 x i32> [[SRC]], i32 3
 ; DEFAULT-NEXT:    [[RES_I3:%.*]] = select i1 [[INDEX_IS_3]], i32 [[VAL]], i32 [[SRC_I3]]
-; DEFAULT-NEXT:    [[RES_UPTO0:%.*]] = insertelement <4 x i32> undef, i32 [[RES_I0]], i32 0
+; DEFAULT-NEXT:    [[RES_UPTO0:%.*]] = insertelement <4 x i32> poison, i32 [[RES_I0]], i32 0
 ; DEFAULT-NEXT:    [[RES_UPTO1:%.*]] = insertelement <4 x i32> [[RES_UPTO0]], i32 [[RES_I1]], i32 1
 ; DEFAULT-NEXT:    [[RES_UPTO2:%.*]] = insertelement <4 x i32> [[RES_UPTO1]], i32 [[RES_I2]], i32 2
 ; DEFAULT-NEXT:    [[RES:%.*]] = insertelement <4 x i32> [[RES_UPTO2]], i32 [[RES_I3]], i32 3
 ; DEFAULT-NEXT:    ret <4 x i32> [[RES]]
 ;
 ; OFF-LABEL: @f1(
 ; OFF-NEXT:    [[RES:%.*]] = insertelement <4 x i32> [[SRC:%.*]], i32 [[VAL:%.*]], i32 [[INDEX:%.*]]
 ; OFF-NEXT:    ret <4 x i32> [[RES]]

 ; DEFAULT-NEXT:    [[VAL1_I2:%.*]] = select i1 [[INDEX_IS_2]], i32 1, i32 [[VAL0_I2]]
 ; DEFAULT-NEXT:    [[INDEX_IS_3:%.*]] = icmp eq i32 [[INDEX]], 3
 ; DEFAULT-NEXT:    [[VAL0_I3:%.*]] = extractelement <4 x i32> [[VAL0]], i32 3
 ; DEFAULT-NEXT:    [[VAL1_I3:%.*]] = select i1 [[INDEX_IS_3]], i32 1, i32 [[VAL0_I3]]
 ; DEFAULT-NEXT:    [[VAL2_I0:%.*]] = shl i32 1, [[VAL1_I0]]
 ; DEFAULT-NEXT:    [[VAL2_I1:%.*]] = shl i32 2, [[VAL1_I1]]
 ; DEFAULT-NEXT:    [[VAL2_I2:%.*]] = shl i32 3, [[VAL1_I2]]
 ; DEFAULT-NEXT:    [[VAL2_I3:%.*]] = shl i32 4, [[VAL1_I3]]
-; DEFAULT-NEXT:    [[VAL2_UPTO0:%.*]] = insertelement <4 x i32> undef, i32 [[VAL2_I0]], i32 0
+; DEFAULT-NEXT:    [[VAL2_UPTO0:%.*]] = insertelement <4 x i32> poison, i32 [[VAL2_I0]], i32 0
 ; DEFAULT-NEXT:    [[VAL2_UPTO1:%.*]] = insertelement <4 x i32> [[VAL2_UPTO0]], i32 [[VAL2_I1]], i32 1
 ; DEFAULT-NEXT:    [[VAL2_UPTO2:%.*]] = insertelement <4 x i32> [[VAL2_UPTO1]], i32 [[VAL2_I2]], i32 2
 ; DEFAULT-NEXT:    [[VAL2:%.*]] = insertelement <4 x i32> [[VAL2_UPTO2]], i32 [[VAL2_I3]], i32 3
 ; DEFAULT-NEXT:    store <4 x i32> [[VAL2]], <4 x i32>* [[DEST:%.*]], align 16
 ; DEFAULT-NEXT:    ret void
 ;
 ; OFF-LABEL: @f2(
 ; OFF-NEXT:    [[VAL0:%.*]] = load <4 x i32>, <4 x i32>* [[SRC:%.*]], align 16
 ; OFF-NEXT:    [[VAL1:%.*]] = insertelement <4 x i32> [[VAL0]], i32 1, i32 [[INDEX:%.*]]
 ; OFF-NEXT:    [[VAL1_I0:%.*]] = extractelement <4 x i32> [[VAL1]], i32 0
 ; OFF-NEXT:    [[VAL2_I0:%.*]] = shl i32 1, [[VAL1_I0]]
 ; OFF-NEXT:    [[VAL1_I1:%.*]] = extractelement <4 x i32> [[VAL1]], i32 1
 ; OFF-NEXT:    [[VAL2_I1:%.*]] = shl i32 2, [[VAL1_I1]]
 ; OFF-NEXT:    [[VAL1_I2:%.*]] = extractelement <4 x i32> [[VAL1]], i32 2
 ; OFF-NEXT:    [[VAL2_I2:%.*]] = shl i32 3, [[VAL1_I2]]
 ; OFF-NEXT:    [[VAL1_I3:%.*]] = extractelement <4 x i32> [[VAL1]], i32 3
 ; OFF-NEXT:    [[VAL2_I3:%.*]] = shl i32 4, [[VAL1_I3]]
-; OFF-NEXT:    [[VAL2_UPTO0:%.*]] = insertelement <4 x i32> undef, i32 [[VAL2_I0]], i32 0
+; OFF-NEXT:    [[VAL2_UPTO0:%.*]] = insertelement <4 x i32> poison, i32 [[VAL2_I0]], i32 0
 ; OFF-NEXT:    [[VAL2_UPTO1:%.*]] = insertelement <4 x i32> [[VAL2_UPTO0]], i32 [[VAL2_I1]], i32 1
 ; OFF-NEXT:    [[VAL2_UPTO2:%.*]] = insertelement <4 x i32> [[VAL2_UPTO1]], i32 [[VAL2_I2]], i32 2
 ; OFF-NEXT:    [[VAL2:%.*]] = insertelement <4 x i32> [[VAL2_UPTO2]], i32 [[VAL2_I3]], i32 3
 ; OFF-NEXT:    store <4 x i32> [[VAL2]], <4 x i32>* [[DEST:%.*]], align 16
 ; OFF-NEXT:    ret void
 ;
   %val0 = load <4 x i32> , <4 x i32> *%src
   %val1 = insertelement <4 x i32> %val0, i32 1, i32 %index
   %val2 = shl <4 x i32> <i32 1, i32 2, i32 3, i32 4>, %val1
   store <4 x i32> %val2, <4 x i32> *%dest
   ret void
 }