Replace un-demanded values with undef in BDCE.

[resistor]

Summary

Unit test changes spot-verified with alive2. As expected, the
transformation is NOT valid with poison.

[nlopes]

I must say that this patch is a bit annoying :)
We are trying to remove undef, and you're adding yet another use.
It's true we can't use poison here. The alternative in the no-undef world is 'freeze poison'. Or just leave the zero there.
Is this change important? If not, I would prefer to not do it, as we'll have to revert it when removing undef (hopefully later this year).
Thanks!

[nikic]

Agree with @nlopes. I think we should just drop the FIXME here and explain why we're using zero. Using freeze undef is unlikely to be worthwhile, especially as it will get folded to 0 most of the time anyway.

[resistor]

Removing the FIXME in https://reviews.llvm.org/D141344

llvm/lib/Transforms/Scalar/BDCE.cpp

for (Use &U : I.operands()) {
         continue;
 
       if (!DB.isUseDead(&U))
         continue;
 
       LLVM_DEBUG(dbgs() << "BDCE: Trivializing: " << U << " (all bits dead)\n");
 
       clearAssumptionsOfUsers(&I, DB);
-
-      // FIXME: In theory we could substitute undef here instead of zero.
-      // This should be reconsidered once we settle on the semantics of
-      // undef, poison, etc.
-      U.set(ConstantInt::get(U->getType(), 0));
+      U.set(UndefValue::get(U->getType()));
       ++NumSimplified;
       Changed = true;
     }
   }
 
   for (Instruction *&I : llvm::reverse(Worklist)) {
     salvageDebugInfo(*I);
     I->dropAllReferences();

llvm/test/Transforms/BDCE/dead-uses.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=bdce -S < %s | FileCheck %s
 
 ; Funnel shift based rotate test cases from PR39771
 
 declare i32 @llvm.fshr.i32(i32, i32, i32)
 declare <2 x i32> @llvm.fshr.v2i32(<2 x i32>, <2 x i32>, <2 x i32>)
 
 ; First fshr operand is dead.
 define i32 @pr39771_fshr_multi_use_instr(i32 %a) {
 ; CHECK-LABEL: @pr39771_fshr_multi_use_instr(
 ; CHECK-NEXT:    [[X:%.*]] = or i32 [[A:%.*]], 0
-; CHECK-NEXT:    [[B:%.*]] = tail call i32 @llvm.fshr.i32(i32 0, i32 [[X]], i32 1)
+; CHECK-NEXT:    [[B:%.*]] = tail call i32 @llvm.fshr.i32(i32 undef, i32 [[X]], i32 1)
 ; CHECK-NEXT:    [[C:%.*]] = lshr i32 [[B]], 23
 ; CHECK-NEXT:    [[D:%.*]] = xor i32 [[C]], [[B]]
 ; CHECK-NEXT:    [[E:%.*]] = and i32 [[D]], 31
 ; CHECK-NEXT:    ret i32 [[E]]
 ;
   %x = or i32 %a, 0
   %b = tail call i32 @llvm.fshr.i32(i32 %x, i32 %x, i32 1)
   %c = lshr i32 %b, 23
   %d = xor i32 %c, %b
   %e = and i32 %d, 31
   ret i32 %e
 }
 
 ; First fshr operand is dead (vector variant).
 define <2 x i32> @pr39771_fshr_multi_use_instr_vec(<2 x i32> %a) {
 ; CHECK-LABEL: @pr39771_fshr_multi_use_instr_vec(
 ; CHECK-NEXT:    [[X:%.*]] = or <2 x i32> [[A:%.*]], zeroinitializer
-; CHECK-NEXT:    [[B:%.*]] = tail call <2 x i32> @llvm.fshr.v2i32(<2 x i32> zeroinitializer, <2 x i32> [[X]], <2 x i32> <i32 1, i32 1>)
+; CHECK-NEXT:    [[B:%.*]] = tail call <2 x i32> @llvm.fshr.v2i32(<2 x i32> undef, <2 x i32> [[X]], <2 x i32> <i32 1, i32 1>)
 ; CHECK-NEXT:    [[C:%.*]] = lshr <2 x i32> [[B]], <i32 23, i32 23>
 ; CHECK-NEXT:    [[D:%.*]] = xor <2 x i32> [[C]], [[B]]
 ; CHECK-NEXT:    [[E:%.*]] = and <2 x i32> [[D]], <i32 31, i32 31>
 ; CHECK-NEXT:    ret <2 x i32> [[E]]
 ;
   %x = or <2 x i32> %a, zeroinitializer
   %b = tail call <2 x i32> @llvm.fshr.v2i32(<2 x i32> %x, <2 x i32> %x, <2 x i32> <i32 1, i32 1>)
   %c = lshr <2 x i32> %b, <i32 23, i32 23>
   %d = xor <2 x i32> %c, %b
   %e = and <2 x i32> %d, <i32 31, i32 31>
   ret <2 x i32> %e
 }
 
 ; First fshr operand is dead, but it comes from an argument, not instruction.
 define i32 @pr39771_fshr_multi_use_arg(i32 %a) {
 ; CHECK-LABEL: @pr39771_fshr_multi_use_arg(
-; CHECK-NEXT:    [[B:%.*]] = tail call i32 @llvm.fshr.i32(i32 0, i32 [[A:%.*]], i32 1)
+; CHECK-NEXT:    [[B:%.*]] = tail call i32 @llvm.fshr.i32(i32 undef, i32 [[A:%.*]], i32 1)
 ; CHECK-NEXT:    [[C:%.*]] = lshr i32 [[B]], 23
 ; CHECK-NEXT:    [[D:%.*]] = xor i32 [[C]], [[B]]
 ; CHECK-NEXT:    [[E:%.*]] = and i32 [[D]], 31
 ; CHECK-NEXT:    ret i32 [[E]]
 ;
   %b = tail call i32 @llvm.fshr.i32(i32 %a, i32 %a, i32 1)
   %c = lshr i32 %b, 23
   %d = xor i32 %c, %b
   %e = and i32 %d, 31
   ret i32 %e
 }
 
 define i32 @pr39771_expanded_fshr_multi_use(i32 %a) {
 ; CHECK-LABEL: @pr39771_expanded_fshr_multi_use(
 ; CHECK-NEXT:    [[TMP:%.*]] = lshr i32 [[A:%.*]], 1
-; CHECK-NEXT:    [[TMP2:%.*]] = shl i32 0, 31
+; CHECK-NEXT:    [[TMP2:%.*]] = shl i32 undef, 31
 ; CHECK-NEXT:    [[B:%.*]] = or i32 [[TMP]], [[TMP2]]
 ; CHECK-NEXT:    [[C:%.*]] = lshr i32 [[B]], 23
 ; CHECK-NEXT:    [[D:%.*]] = xor i32 [[C]], [[B]]
 ; CHECK-NEXT:    [[E:%.*]] = and i32 [[D]], 31
 ; CHECK-NEXT:    ret i32 [[E]]
 ;
   %tmp = lshr i32 %a, 1
   %tmp2 = shl i32 %a, 31

llvm/test/Transforms/BDCE/intrinsics.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -passes=bdce < %s | FileCheck %s
 
 declare i8 @llvm.umax.i8(i8, i8)
 declare i8 @llvm.umin.i8(i8, i8)
 declare i8 @llvm.smax.i8(i8, i8)
 declare i8 @llvm.smin.i8(i8, i8)
 
 define i8 @umax(i8 %x, i8 %y, i1 %a, i1 %b) {
 ; CHECK-LABEL: @umax(
-; CHECK-NEXT:    [[A2:%.*]] = zext i1 false to i8
-; CHECK-NEXT:    [[B2:%.*]] = zext i1 false to i8
+; CHECK-NEXT:    [[A2:%.*]] = zext i1 undef to i8
+; CHECK-NEXT:    [[B2:%.*]] = zext i1 undef to i8
 ; CHECK-NEXT:    [[X2:%.*]] = or i8 [[X:%.*]], [[A2]]
 ; CHECK-NEXT:    [[Y2:%.*]] = or i8 [[Y:%.*]], [[B2]]
 ; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.umax.i8(i8 [[X2]], i8 [[Y2]])
 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[M]], 1
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %a2 = zext i1 %a to i8
   %b2 = zext i1 %b to i8
   %x2 = or i8 %x, %a2
   %y2 = or i8 %y, %b2
   %m = call i8 @llvm.umax.i8(i8 %x2, i8 %y2)
   %r = lshr i8 %m, 1
   ret i8 %r
 }
 
 define i8 @umin(i8 %x, i8 %y, i1 %a, i1 %b) {
 ; CHECK-LABEL: @umin(
-; CHECK-NEXT:    [[A2:%.*]] = zext i1 false to i8
-; CHECK-NEXT:    [[B2:%.*]] = zext i1 false to i8
+; CHECK-NEXT:    [[A2:%.*]] = zext i1 undef to i8
+; CHECK-NEXT:    [[B2:%.*]] = zext i1 undef to i8
 ; CHECK-NEXT:    [[X2:%.*]] = or i8 [[X:%.*]], [[A2]]
 ; CHECK-NEXT:    [[Y2:%.*]] = or i8 [[Y:%.*]], [[B2]]
 ; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.umin.i8(i8 [[X2]], i8 [[Y2]])
 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[M]], 1
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %a2 = zext i1 %a to i8
   %b2 = zext i1 %b to i8
   %x2 = or i8 %x, %a2
   %y2 = or i8 %y, %b2
   %m = call i8 @llvm.umin.i8(i8 %x2, i8 %y2)
   %r = lshr i8 %m, 1
   ret i8 %r
 }
 
 define i8 @smax(i8 %x, i8 %y, i1 %a, i1 %b) {
 ; CHECK-LABEL: @smax(
-; CHECK-NEXT:    [[A2:%.*]] = zext i1 false to i8
-; CHECK-NEXT:    [[B2:%.*]] = zext i1 false to i8
+; CHECK-NEXT:    [[A2:%.*]] = zext i1 undef to i8
+; CHECK-NEXT:    [[B2:%.*]] = zext i1 undef to i8
 ; CHECK-NEXT:    [[X2:%.*]] = or i8 [[X:%.*]], [[A2]]
 ; CHECK-NEXT:    [[Y2:%.*]] = or i8 [[Y:%.*]], [[B2]]
 ; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smax.i8(i8 [[X2]], i8 [[Y2]])
 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[M]], 1
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %a2 = zext i1 %a to i8
   %b2 = zext i1 %b to i8
   %x2 = or i8 %x, %a2
   %y2 = or i8 %y, %b2
   %m = call i8 @llvm.smax.i8(i8 %x2, i8 %y2)
   %r = lshr i8 %m, 1
   ret i8 %r
 }
 
 define i8 @smin(i8 %x, i8 %y, i1 %a, i1 %b) {
 ; CHECK-LABEL: @smin(
-; CHECK-NEXT:    [[A2:%.*]] = zext i1 false to i8
-; CHECK-NEXT:    [[B2:%.*]] = zext i1 false to i8
+; CHECK-NEXT:    [[A2:%.*]] = zext i1 undef to i8
+; CHECK-NEXT:    [[B2:%.*]] = zext i1 undef to i8
 ; CHECK-NEXT:    [[X2:%.*]] = or i8 [[X:%.*]], [[A2]]
 ; CHECK-NEXT:    [[Y2:%.*]] = or i8 [[Y:%.*]], [[B2]]
 ; CHECK-NEXT:    [[M:%.*]] = call i8 @llvm.smin.i8(i8 [[X2]], i8 [[Y2]])
 ; CHECK-NEXT:    [[R:%.*]] = lshr i8 [[M]], 1
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %a2 = zext i1 %a to i8
   %b2 = zext i1 %b to i8
   %x2 = or i8 %x, %a2
   %y2 = or i8 %y, %b2
   %m = call i8 @llvm.smin.i8(i8 %x2, i8 %y2)
   %r = lshr i8 %m, 1
   ret i8 %r
 }

llvm/test/Transforms/BDCE/invalidate-assumptions.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -passes=bdce %s -S | FileCheck %s
 
 ; The 'nuw' on the subtract allows us to deduce that %setbit is not demanded.
 ; But if we change that value to '0', then the 'nuw' is no longer valid. If we don't
 ; remove the 'nuw', another pass (-instcombine) may make a transform based on an
 ; that incorrect assumption and we can miscompile:
 ; https://bugs.llvm.org/show_bug.cgi?id=33695
 
 define i1 @PR33695(i1 %b, i8 %x) {
 ; CHECK-LABEL: @PR33695(
 ; CHECK-NEXT:    [[LITTLE_NUMBER:%.*]] = zext i1 [[B:%.*]] to i8
-; CHECK-NEXT:    [[BIG_NUMBER:%.*]] = shl i8 0, 1
+; CHECK-NEXT:    [[BIG_NUMBER:%.*]] = shl i8 undef, 1
 ; CHECK-NEXT:    [[SUB:%.*]] = sub i8 [[BIG_NUMBER]], [[LITTLE_NUMBER]]
 ; CHECK-NEXT:    [[TRUNC:%.*]] = trunc i8 [[SUB]] to i1
 ; CHECK-NEXT:    ret i1 [[TRUNC]]
 ;
   %setbit = or i8 %x, 64
   %little_number = zext i1 %b to i8
   %big_number = shl i8 %setbit, 1
   %sub = sub nuw i8 %big_number, %little_number
   %trunc = trunc i8 %sub to i1
   ret i1 %trunc
 }
 
 ; Similar to above, but now with more no-wrap.
 ; https://bugs.llvm.org/show_bug.cgi?id=34037
 
 define i64 @PR34037(i64 %m, i32 %r, i64 %j, i1 %b, i32 %k, i64 %p) {
 ; CHECK-LABEL: @PR34037(
-; CHECK-NEXT:    [[SHL:%.*]] = shl i64 0, 29
+; CHECK-NEXT:    [[SHL:%.*]] = shl i64 undef, 29
 ; CHECK-NEXT:    [[CONV1:%.*]] = select i1 [[B:%.*]], i64 7, i64 0
 ; CHECK-NEXT:    [[SUB:%.*]] = sub i64 [[SHL]], [[CONV1]]
 ; CHECK-NEXT:    [[CONV2:%.*]] = zext i32 [[K:%.*]] to i64
 ; CHECK-NEXT:    [[MUL:%.*]] = mul i64 [[SUB]], [[CONV2]]
 ; CHECK-NEXT:    [[CONV4:%.*]] = and i64 [[P:%.*]], 65535
 ; CHECK-NEXT:    [[AND5:%.*]] = and i64 [[MUL]], [[CONV4]]
 ; CHECK-NEXT:    ret i64 [[AND5]]
 ;

 ; assumption-killing algorithm stops at the call. Ie, it does not remove
 ; nsw/nuw from the 'add' because a call demands all bits of its argument.
 
 declare i1 @foo(i1)
 
 define i1 @poison_on_call_user_is_ok(i1 %b, i8 %x) {
 ; CHECK-LABEL: @poison_on_call_user_is_ok(
 ; CHECK-NEXT:    [[LITTLE_NUMBER:%.*]] = zext i1 [[B:%.*]] to i8
-; CHECK-NEXT:    [[BIG_NUMBER:%.*]] = shl i8 0, 1
+; CHECK-NEXT:    [[BIG_NUMBER:%.*]] = shl i8 undef, 1
 ; CHECK-NEXT:    [[SUB:%.*]] = sub i8 [[BIG_NUMBER]], [[LITTLE_NUMBER]]
 ; CHECK-NEXT:    [[TRUNC:%.*]] = trunc i8 [[SUB]] to i1
 ; CHECK-NEXT:    [[CALL_RESULT:%.*]] = call i1 @foo(i1 [[TRUNC]])
 ; CHECK-NEXT:    [[ADD:%.*]] = add nuw nsw i1 [[CALL_RESULT]], true
 ; CHECK-NEXT:    [[MUL:%.*]] = mul i1 [[TRUNC]], [[ADD]]
 ; CHECK-NEXT:    ret i1 [[MUL]]
 ;
   %setbit = or i8 %x, 64
   %little_number = zext i1 %b to i8
   %big_number = shl i8 %setbit, 1
   %sub = sub nuw i8 %big_number, %little_number
   %trunc = trunc i8 %sub to i1
   %call_result = call i1 @foo(i1 %trunc)
   %add = add nsw nuw i1 %call_result, 1
   %mul = mul i1 %trunc, %add
   ret i1 %mul
 }
 
 
 ; We were asserting that all users of a trivialized integer-type instruction were
 ; also integer-typed, but that's too strong. The alloca has a pointer-type result.
 
 define void @PR34179(ptr %a) {
 ; CHECK-LABEL: @PR34179(
-; CHECK-NEXT:    [[T0:%.*]] = load volatile i32, ptr [[A:%.*]]
+; CHECK-NEXT:    [[T0:%.*]] = load volatile i32, ptr [[A:%.*]], align 4
 ; CHECK-NEXT:    ret void
 ;
   %t0 = load volatile i32, ptr %a
   %vla = alloca i32, i32 %t0
   ret void
 }
 

llvm/test/Transforms/BDCE/vectors-inseltpoison.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -passes=bdce < %s | FileCheck %s
 
 ; BDCE applied to integer vectors.
 
 define <2 x i32> @test_basic(<2 x i32> %a, <2 x i32> %b) {
 ; CHECK-LABEL: @test_basic(
-; CHECK-NEXT:    [[A3:%.*]] = and <2 x i32> zeroinitializer, <i32 4, i32 4>
+; CHECK-NEXT:    [[A3:%.*]] = and <2 x i32> undef, <i32 4, i32 4>
 ; CHECK-NEXT:    [[B2:%.*]] = add <2 x i32> [[B:%.*]], <i32 1, i32 1>
 ; CHECK-NEXT:    [[B3:%.*]] = and <2 x i32> [[B2]], <i32 8, i32 8>
 ; CHECK-NEXT:    [[C:%.*]] = or <2 x i32> [[A3]], [[B3]]
 ; CHECK-NEXT:    [[D:%.*]] = ashr <2 x i32> [[C]], <i32 3, i32 3>
 ; CHECK-NEXT:    ret <2 x i32> [[D]]
 ;
   %a2 = add <2 x i32> %a, <i32 1, i32 1>
   %a3 = and <2 x i32> %a2, <i32 4, i32 4>
   %b2 = add <2 x i32> %b, <i32 1, i32 1>
   %b3 = and <2 x i32> %b2, <i32 8, i32 8>
   %c = or <2 x i32> %a3, %b3
   %d = ashr <2 x i32> %c, <i32 3, i32 3>
   ret <2 x i32> %d
 }
 
 ; Going vector -> scalar
 define i32 @test_extractelement(<2 x i32> %a, <2 x i32> %b) {
 ; CHECK-LABEL: @test_extractelement(
-; CHECK-NEXT:    [[A3:%.*]] = and <2 x i32> zeroinitializer, <i32 4, i32 4>
+; CHECK-NEXT:    [[A3:%.*]] = and <2 x i32> undef, <i32 4, i32 4>
 ; CHECK-NEXT:    [[B2:%.*]] = add <2 x i32> [[B:%.*]], <i32 1, i32 1>
 ; CHECK-NEXT:    [[B3:%.*]] = and <2 x i32> [[B2]], <i32 8, i32 8>
 ; CHECK-NEXT:    [[C:%.*]] = or <2 x i32> [[A3]], [[B3]]
 ; CHECK-NEXT:    [[D:%.*]] = extractelement <2 x i32> [[C]], i32 0
 ; CHECK-NEXT:    [[E:%.*]] = ashr i32 [[D]], 3
 ; CHECK-NEXT:    ret i32 [[E]]
 ;
   %a2 = add <2 x i32> %a, <i32 1, i32 1>
   %a3 = and <2 x i32> %a2, <i32 4, i32 4>
   %b2 = add <2 x i32> %b, <i32 1, i32 1>
   %b3 = and <2 x i32> %b2, <i32 8, i32 8>
   %c = or <2 x i32> %a3, %b3
   %d = extractelement <2 x i32> %c, i32 0
   %e = ashr i32 %d, 3
   ret i32 %e
 }
 
 ; Going scalar -> vector
 define <2 x i32> @test_insertelement(i32 %a, i32 %b) {
 ; CHECK-LABEL: @test_insertelement(
-; CHECK-NEXT:    [[X3:%.*]] = and <2 x i32> zeroinitializer, <i32 4, i32 4>
+; CHECK-NEXT:    [[X3:%.*]] = and <2 x i32> undef, <i32 4, i32 4>
 ; CHECK-NEXT:    [[Y:%.*]] = insertelement <2 x i32> poison, i32 [[B:%.*]], i32 0
 ; CHECK-NEXT:    [[Y2:%.*]] = insertelement <2 x i32> [[Y]], i32 [[A:%.*]], i32 1
 ; CHECK-NEXT:    [[Y3:%.*]] = and <2 x i32> [[Y2]], <i32 8, i32 8>
 ; CHECK-NEXT:    [[Z:%.*]] = or <2 x i32> [[X3]], [[Y3]]
 ; CHECK-NEXT:    [[U:%.*]] = ashr <2 x i32> [[Z]], <i32 3, i32 3>
 ; CHECK-NEXT:    ret <2 x i32> [[U]]
 ;
   %x = insertelement <2 x i32> poison, i32 %a, i32 0
;
   %u = ashr <2 x i32> %z, <i32 3, i32 3>
   ret <2 x i32> %u
 }
 
 ; Assumption invalidation (adapted from invalidate-assumptions.ll)
 define <2 x i1> @test_assumption_invalidation(<2 x i1> %b, <2 x i8> %x) {
 ; CHECK-LABEL: @test_assumption_invalidation(
 ; CHECK-NEXT:    [[LITTLE_NUMBER:%.*]] = zext <2 x i1> [[B:%.*]] to <2 x i8>
-; CHECK-NEXT:    [[BIG_NUMBER:%.*]] = shl <2 x i8> zeroinitializer, <i8 1, i8 1>
+; CHECK-NEXT:    [[BIG_NUMBER:%.*]] = shl <2 x i8> undef, <i8 1, i8 1>
 ; CHECK-NEXT:    [[SUB:%.*]] = sub <2 x i8> [[BIG_NUMBER]], [[LITTLE_NUMBER]]
 ; CHECK-NEXT:    [[TRUNC:%.*]] = trunc <2 x i8> [[SUB]] to <2 x i1>
 ; CHECK-NEXT:    ret <2 x i1> [[TRUNC]]
 ;
   %setbit = or <2 x i8> %x, <i8 64, i8 64>
   %little_number = zext <2 x i1> %b to <2 x i8>
   %big_number = shl <2 x i8> %setbit, <i8 1, i8 1>
   %sub = sub nuw <2 x i8> %big_number, %little_number
   %trunc = trunc <2 x i8> %sub to <2 x i1>
   ret <2 x i1> %trunc
 }

llvm/test/Transforms/BDCE/vectors.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -passes=bdce < %s | FileCheck %s
 
 ; BDCE applied to integer vectors.
 
 define <2 x i32> @test_basic(<2 x i32> %a, <2 x i32> %b) {
 ; CHECK-LABEL: @test_basic(
-; CHECK-NEXT:    [[A3:%.*]] = and <2 x i32> zeroinitializer, <i32 4, i32 4>
+; CHECK-NEXT:    [[A3:%.*]] = and <2 x i32> undef, <i32 4, i32 4>
 ; CHECK-NEXT:    [[B2:%.*]] = add <2 x i32> [[B:%.*]], <i32 1, i32 1>
 ; CHECK-NEXT:    [[B3:%.*]] = and <2 x i32> [[B2]], <i32 8, i32 8>
 ; CHECK-NEXT:    [[C:%.*]] = or <2 x i32> [[A3]], [[B3]]
 ; CHECK-NEXT:    [[D:%.*]] = ashr <2 x i32> [[C]], <i32 3, i32 3>
 ; CHECK-NEXT:    ret <2 x i32> [[D]]
 ;
   %a2 = add <2 x i32> %a, <i32 1, i32 1>
   %a3 = and <2 x i32> %a2, <i32 4, i32 4>
   %b2 = add <2 x i32> %b, <i32 1, i32 1>
   %b3 = and <2 x i32> %b2, <i32 8, i32 8>
   %c = or <2 x i32> %a3, %b3
   %d = ashr <2 x i32> %c, <i32 3, i32 3>
   ret <2 x i32> %d
 }
 
 ; Going vector -> scalar
 define i32 @test_extractelement(<2 x i32> %a, <2 x i32> %b) {
 ; CHECK-LABEL: @test_extractelement(
-; CHECK-NEXT:    [[A3:%.*]] = and <2 x i32> zeroinitializer, <i32 4, i32 4>
+; CHECK-NEXT:    [[A3:%.*]] = and <2 x i32> undef, <i32 4, i32 4>
 ; CHECK-NEXT:    [[B2:%.*]] = add <2 x i32> [[B:%.*]], <i32 1, i32 1>
 ; CHECK-NEXT:    [[B3:%.*]] = and <2 x i32> [[B2]], <i32 8, i32 8>
 ; CHECK-NEXT:    [[C:%.*]] = or <2 x i32> [[A3]], [[B3]]
 ; CHECK-NEXT:    [[D:%.*]] = extractelement <2 x i32> [[C]], i32 0
 ; CHECK-NEXT:    [[E:%.*]] = ashr i32 [[D]], 3
 ; CHECK-NEXT:    ret i32 [[E]]
 ;
   %a2 = add <2 x i32> %a, <i32 1, i32 1>
   %a3 = and <2 x i32> %a2, <i32 4, i32 4>
   %b2 = add <2 x i32> %b, <i32 1, i32 1>
   %b3 = and <2 x i32> %b2, <i32 8, i32 8>
   %c = or <2 x i32> %a3, %b3
   %d = extractelement <2 x i32> %c, i32 0
   %e = ashr i32 %d, 3
   ret i32 %e
 }
 
 ; Going scalar -> vector
 define <2 x i32> @test_insertelement(i32 %a, i32 %b) {
 ; CHECK-LABEL: @test_insertelement(
-; CHECK-NEXT:    [[X3:%.*]] = and <2 x i32> zeroinitializer, <i32 4, i32 4>
+; CHECK-NEXT:    [[X3:%.*]] = and <2 x i32> undef, <i32 4, i32 4>
 ; CHECK-NEXT:    [[Y:%.*]] = insertelement <2 x i32> undef, i32 [[B:%.*]], i32 0
 ; CHECK-NEXT:    [[Y2:%.*]] = insertelement <2 x i32> [[Y]], i32 [[A:%.*]], i32 1
 ; CHECK-NEXT:    [[Y3:%.*]] = and <2 x i32> [[Y2]], <i32 8, i32 8>
 ; CHECK-NEXT:    [[Z:%.*]] = or <2 x i32> [[X3]], [[Y3]]
 ; CHECK-NEXT:    [[U:%.*]] = ashr <2 x i32> [[Z]], <i32 3, i32 3>
 ; CHECK-NEXT:    ret <2 x i32> [[U]]
 ;
   %x = insertelement <2 x i32> undef, i32 %a, i32 0
;
   %u = ashr <2 x i32> %z, <i32 3, i32 3>
   ret <2 x i32> %u
 }
 
 ; Assumption invalidation (adapted from invalidate-assumptions.ll)
 define <2 x i1> @test_assumption_invalidation(<2 x i1> %b, <2 x i8> %x) {
 ; CHECK-LABEL: @test_assumption_invalidation(
 ; CHECK-NEXT:    [[LITTLE_NUMBER:%.*]] = zext <2 x i1> [[B:%.*]] to <2 x i8>
-; CHECK-NEXT:    [[BIG_NUMBER:%.*]] = shl <2 x i8> zeroinitializer, <i8 1, i8 1>
+; CHECK-NEXT:    [[BIG_NUMBER:%.*]] = shl <2 x i8> undef, <i8 1, i8 1>
 ; CHECK-NEXT:    [[SUB:%.*]] = sub <2 x i8> [[BIG_NUMBER]], [[LITTLE_NUMBER]]
 ; CHECK-NEXT:    [[TRUNC:%.*]] = trunc <2 x i8> [[SUB]] to <2 x i1>
 ; CHECK-NEXT:    ret <2 x i1> [[TRUNC]]
 ;
   %setbit = or <2 x i8> %x, <i8 64, i8 64>
   %little_number = zext <2 x i1> %b to <2 x i8>
   %big_number = shl <2 x i8> %setbit, <i8 1, i8 1>
   %sub = sub nuw <2 x i8> %big_number, %little_number
   %trunc = trunc <2 x i8> %sub to <2 x i1>
   ret <2 x i1> %trunc
 }